home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 071-080 / amok71 / ausgleichsgerade / ausgleichsgeradev2.mod < prev    next >
Text File  |  1993-11-04  |  103KB  |  3,167 lines
  1. (**************************************************************************
  2.  
  3.  
  4. :Program.       MODULE AusgleichsgeradeV2
  5.  
  6. :Contents.      berechnet und zeichnet eine Ausgleichsgerade
  7.  
  8. :Usage.         AusgleichsgeradeV2
  9.  
  10.  
  11. :Copyright.     © 1990, 1991 by
  12.  
  13. :Author.        Thomas Ansorge
  14.  
  15. :Address.       Dinkelackerring 55, W-6730 Neustadt, Deutschland
  16.  
  17.  
  18. :Language.      Modula-2
  19.  
  20. :Translator.    M2Amiga V4.0 (deutsch)
  21.  
  22. :Imports.       OpenClose [Thomas Ansorge]
  23.  
  24.  
  25. :Version.       Version 2.1 vom 20.04.1992
  26.  
  27. :History.       1.0 vom 23.12.1990 erste Version
  28. :History.       1.1 vom 25.02.1991 mit bekanntem Parameter B
  29. :History.       2.0 vom 01.04.1991 mit komplettem Intuition-Interface
  30. :History.           anstelle des Ja/Nein-Spielchens in der Shell
  31. :History.       2.1 vom 20.04.1992 zeichnet und druckt Ausgleichsgerade
  32.  
  33.  
  34. **************************************************************************)
  35.  
  36.  
  37. MODULE AusgleichsgeradeV2;
  38.  
  39. FROM Arts IMPORT Assert;
  40.  
  41. FROM ASCII IMPORT eol;
  42.  
  43. FROM Conversions IMPORT StrToVal, ValToStr;
  44.  
  45. FROM DosD IMPORT FileHandlePtr, newFile;
  46.  
  47. FROM DosL IMPORT Write;
  48.  
  49. FROM ExecD IMPORT MsgPortPtr;
  50.  
  51. FROM ExecL IMPORT CloseDevice, DoIO, GetMsg, OpenDevice, ReplyMsg, WaitPort;
  52.  
  53. FROM ExecSupport IMPORT CreateExtIO, DeleteExtIO;
  54.  
  55. FROM FileSystem IMPORT File;
  56.  
  57. FROM GraphicsD IMPORT jam2, FontFlags, FontFlagSet, FontStyles,
  58.    FontStyleSet, RastPortPtr, TextFont, TextFontPtr, ViewModes, ViewModeSet,
  59.    ViewPort, ViewPortPtr, TextAttr, TextAttrPtr;
  60.  
  61. FROM GraphicsL IMPORT Draw, Move, RectFill, SetAPen, SetRGB4;
  62.  
  63. FROM Heap IMPORT Allocate, Deallocate, Largest;
  64.  
  65. FROM IntuitionD IMPORT ActivationFlags, ActivationFlagSet, boolGadget,
  66.    Border, BorderPtr, customScreen, Gadget, GadgetPtr, GadgetFlags,
  67.    GadgetFlagSet, IDCMPFlags, IDCMPFlagSet, IntuiMessage, IntuiMessagePtr,
  68.    IntuiText, IntuiTextPtr, NewScreen, NewWindow, Preferences, reqGadget,
  69.    Requester, RequesterFlags, RequesterFlagSet, RequesterPtr, Screen,
  70.    ScreenFlags, ScreenFlagSet, ScreenPtr, strGadget, StringInfo, Window,
  71.    WindowFlags, WindowFlagSet, WindowPtr;
  72.  
  73. FROM IntuitionL IMPORT ActivateGadget, DrawBorder, PrintIText, OffGadget,
  74.    OnGadget, RefreshGList, Request;
  75.  
  76. FROM LongRealConversions IMPORT RealToStr, StrToReal;
  77.  
  78. FROM MathLibLong IMPORT sqrt;
  79.  
  80. FROM OpenClose IMPORT Close, CloseFont, CloseScreen, CloseWindow, CreatePort,
  81.    DeletePort, Open, OpenFont, OpenScreen, OpenWindow;
  82.  
  83. FROM Printer IMPORT dumpRPort, IODRPReq, IODRPReqPtr, printerName,
  84.    Special, SpecialSet;
  85.  
  86. FROM String IMPORT Concat, Delete, FirstPos, Insert, Length;
  87.  
  88. FROM SYSTEM IMPORT ADDRESS, ADR, LONGSET;
  89.  
  90. (* --------------------------------------------------------------------- *)
  91.  
  92. CONST (* der Font *)
  93.       FontName  = "topaz.font\o";
  94.       FontHoehe = 9;
  95.  
  96.       (* der Screen *)
  97.       Screentitel   = "Ausgleichsgerade Version 2.1d\o";
  98.       Fenstertitel  = "© 1992 Thomas Ansorge, Dinkelackerring 55, W-6730 Neustadt\o";
  99.       Fenstertitel2 = "die Daten der Ausgleichsgerade:\o";
  100.       Fenstertitel3 = "die Grafik der Ausgleichsgeraden:\o";
  101.  
  102.       (* die Screenfarben: *)
  103.       Blaugrau  = 0;
  104.       Hellblau  = 1;
  105.       Schwarz   = 2;
  106.       Dunkelrot = 3;
  107.       Weissrot  = 4;
  108.       Weiss     = 5;
  109.       Rot       = 6;
  110.       Gelb      = 7;
  111.  
  112.       (* Fehlermeldungen bei Assert *)
  113.       Speichermangel = "nicht genug freier Speicher!";
  114.  
  115.       (* für den Requester *)
  116.       Ok   = "Ok\o";
  117.       Ja   = "Ja\o";
  118.       Nein = "Nein\o";
  119.  
  120.       (* für die Ausgabe *)
  121.       PRT = "PRT:\o";
  122.  
  123.       (* für die Gadgets (Trick 17) *)
  124.       Space3  = "   \o";
  125.       Space8  = "        \o";
  126.       Space9  = "         \o";
  127.       Space10 = "          \o";
  128.       Space16 = "                \o";
  129.       Space27 = "                           \o";
  130.  
  131.       (* für die Zeichnung *)
  132.       SpalteMax = 627;
  133.       SpalteMin = 6;
  134.       ZeileMax  = 179;
  135.       ZeileMin  = 13;
  136.  
  137. TYPE (* alles wissenswerte über die Ausgleichsgerade *)
  138.      AGerade = RECORD
  139.                   N       : CARDINAL; (* Anzahl der Werte *)
  140.                   M       : CARDINAL; (* momentan angezeigter Wert *)
  141.                   Groesse : LONGINT; (* Größe des Speicherbereiches *)
  142.                   Adresse : ADDRESS; (* Adresse der Wertepaare *)
  143.                   Disk    : BOOLEAN; (* in dieser Form gespeichert? *)
  144.                   Daten   : RECORD
  145.                                A, B: LONGREAL; (* Parameter Y = AX + B *)
  146.                                XM,
  147.                                YM  : LONGREAL; (* Mittelwerte *)
  148.                                XS,   (* Standardabweichung von X *)
  149.                                YS,   (* dto. von Y *)
  150.                                GS,   (* dto. der Geraden *)
  151.                                AS,   (* dto. von A *)
  152.                                BS  : LONGREAL; (* dto. von B *)
  153.                                R   : LONGREAL; (* Korrelationskoeffizient *)
  154.                             END (* RECORD Daten *);
  155.                   BBekannt: BOOLEAN; (* B vorher bekannt? *)
  156.                END (* RECORD AGerade *);
  157.  
  158.      AnAus = (An, Aus);
  159.  
  160. CONST LongStringMax = 255;
  161.       StringMax     =  60;
  162.  
  163. TYPE LongString = ARRAY [0..LongStringMax] OF CHAR;
  164.      String     = ARRAY [0..StringMax] OF CHAR;
  165.  
  166. TYPE Koordinate = (x, y);
  167.  
  168. VAR (* die aktuelle Ausgleichsgerade *)
  169.     Gerade: AGerade;
  170.  
  171.     (* die Datei auf der Diskette *)
  172.     GerDatei    : File;
  173.     GerDateiname: LongString;
  174.  
  175.     (* zum Rechnen *)
  176.     Wert: POINTER TO LONGREAL;
  177.     XIQQ: LONGREAL; (* Summe (Xi - XM)² (Hilfsvariable) *)
  178.  
  179.     (* für den Font *)
  180.     Attr: TextAttr;
  181.     Font: TextFontPtr;
  182.  
  183.     (* für den Screen *)
  184.     NBildschirm: NewScreen;
  185.     Bildschirm : ScreenPtr;
  186.  
  187.     (* das Fenster mit den Gadgets auf dem Screen *)
  188.     NFenster  : NewWindow;
  189.     BFenster  : WindowPtr;
  190.     Box       : ARRAY [1..23] OF Gadget;
  191.     SInfo     : ARRAY [1..5] OF StringInfo;
  192.     IText     : ARRAY [1..24] OF IntuiText;
  193.     ILeer     : ARRAY [1..36] OF IntuiText;
  194.     Rahmen    : ARRAY [1..12] OF Border;
  195.     Ecken     : ARRAY [1..12], [1..10] OF INTEGER;
  196.     XZahl,
  197.     UXZahl,
  198.     YZahl,
  199.     UYZahl,
  200.     YVonX,
  201.     UYVonX    : ARRAY [0..15] OF CHAR;
  202.     SPaarNr,
  203.     USPaarNr,
  204.     SMaxPaare,
  205.     USMaxPaare: ARRAY [0..6] OF CHAR;
  206.     MaxPaare,
  207.     PaarNr    : LONGINT;
  208.  
  209.     (* Gadgets abfragen *)
  210.     Nachricht: IntuiMessagePtr;
  211.     Flags    : IDCMPFlagSet;
  212.     GewGad   : GadgetPtr;
  213.  
  214.     (* 4 × IntuiText für den Requester *)
  215.     ReqText: ARRAY [1..4] OF IntuiText;
  216.  
  217.     (* für den Ausdruck *)
  218.     Ausgabe,
  219.     SHilfe  : ARRAY [0..80] OF CHAR;
  220.     BildReq : IODRPReqPtr;
  221.     Datei   : FileHandlePtr;
  222.     Port    : MsgPortPtr;
  223.     Ziffern : CARDINAL; (* Anzahl Ziffern von N *)
  224.  
  225.     (* das GrafikFenster *)
  226.     Breite  : LONGREAL;
  227.     GFenster: WindowPtr;
  228.     Hoehe   : LONGREAL;
  229.     ISchrift: IntuiText;
  230.     MBDurchA: LONGREAL;
  231.     Schrift : ARRAY [0..9] OF CHAR;
  232.     X       : INTEGER;
  233.     XPixelBr: LONGREAL;
  234.     XMin,
  235.     XMax    : LONGREAL;
  236.     Y       : INTEGER;
  237.     YPixelBr: LONGREAL;
  238.     YMin,
  239.     YMax    : LONGREAL;
  240.  
  241.     (* Das Datenfenster *)
  242.     DFenster  : WindowPtr;
  243.     HilfsText : String;
  244.     TextZeile : String;
  245.  
  246.     (* diverses *)
  247.     i           : CARDINAL; (* Zähler in FOR-Schleifen *)
  248.     Weiter      : CHAR; (* Hauptsache, Return gedrückt *)
  249.     Hilfe,
  250.     Hilfe2,
  251.     Hilfe3      : LONGREAL; (* wird ab und zu gebraucht *)
  252.     Programmende: BOOLEAN;
  253.     Error       : BOOLEAN;
  254.     ErstesMal   : BOOLEAN;
  255.  
  256. (* --------------------------------------------------------------------- *)
  257.  
  258. (* Damit man die Prozeduren leichter findet, sind sie alphabetisch   *)
  259. (* geordnet. Die folgenden Prozeduren werden in anderen gebraucht    *)
  260. (* und seien deshalb hier dem Compiler bekanntgemacht:               *)
  261.  
  262. PROCEDURE GadgetAn (Gad    : GadgetPtr;
  263.                     Fenster: WindowPtr;
  264.                     Req    : RequesterPtr); FORWARD;
  265.  
  266. PROCEDURE GadgetAus (Gad    : GadgetPtr;
  267.                      Fenster: WindowPtr;
  268.                      Req    : RequesterPtr); FORWARD;
  269.  
  270. (* --------------------------------------------------------------------- *)
  271.  
  272. PROCEDURE AktualisiereG (VAR Box1, Box2, Box3, Box4: Gadget;
  273.                          VAR Fenster               : WindowPtr;
  274.                              Nummer                : LONGINT;
  275.                              Max                   : CARDINAL);
  276.  
  277.    (* aktualisiert die 4 Gadgets +, -, 10+, 10- *)
  278.  
  279.    BEGIN (* Prozedur AktualisiereG *)
  280.  
  281.    (* + ggf. an *)
  282.    IF (Max - CARDINAL (Nummer) > 0) AND
  283.       (gadgDisabled IN Box1.flags) THEN
  284.       GadgetAn (ADR (Box1), Fenster, NIL);
  285.    END (* IF (Max *);
  286.  
  287.    (* + ggf. aus *)
  288.    IF (CARDINAL (Nummer) = Max) AND
  289.       NOT (gadgDisabled IN Box1.flags) THEN
  290.       GadgetAus (ADR (Box1), BFenster, NIL);
  291.    END (* IF (Gerade.M *);
  292.  
  293.    (* - ggf. an *)
  294.    IF (Nummer > 1) AND
  295.       (gadgDisabled IN Box2.flags) THEN
  296.       GadgetAn (ADR (Box2), Fenster, NIL);
  297.    END (* IF Nummer *);
  298.  
  299.    (* - ggf. aus *)
  300.    IF (Nummer = 1) AND
  301.       NOT (gadgDisabled IN Box2.flags) THEN
  302.       GadgetAus (ADR (Box2), Fenster, NIL);
  303.    END (* IF (Nummer *);
  304.  
  305.    (* 10+ ggf. an *)
  306.    IF (Max - CARDINAL (Nummer) > 9) AND
  307.       (gadgDisabled IN Box3.flags) THEN
  308.       GadgetAn (ADR (Box3), Fenster, NIL);
  309.    END (* IF (Max *);
  310.  
  311.    (* 10+ ggf. aus *)
  312.    IF (Max - CARDINAL (Nummer) < 10) AND
  313.       NOT (gadgDisabled IN Box3.flags) THEN
  314.       GadgetAus (ADR (Box3), Fenster, NIL);
  315.    END (* IF (Max *);
  316.  
  317.    (* 10- ggf. an *)
  318.    IF (Nummer > 10) AND
  319.       (gadgDisabled IN Box4.flags) THEN
  320.       GadgetAn (ADR (Box4), Fenster, NIL);
  321.    END (* IF (Nummer *);
  322.  
  323.    (* 10- ggf. aus *)
  324.    IF (Nummer < 11) AND
  325.       NOT (gadgDisabled IN Box4.flags) THEN
  326.       GadgetAus (ADR (Box4), Fenster, NIL);
  327.    END (* IF (Nummer *);
  328. END (* Prozedur *) AktualisiereG;
  329.  
  330. (* --------------------------------------------------------------------- *)
  331.  
  332. PROCEDURE AZiffern (Zahl: LONGINT): INTEGER;
  333.  
  334.    (* berechnet die Anzahl der Ziffern von Zahl *)
  335.  
  336.    BEGIN (* Funktion AZiffern *)
  337.  
  338.    IF Zahl > 9999 THEN
  339.       RETURN 5;
  340.  
  341.    ELSE
  342.       IF Zahl > 999 THEN
  343.          RETURN 4;
  344.  
  345.       ELSE
  346.          IF Zahl > 99 THEN
  347.             RETURN 3;
  348.  
  349.          ELSE
  350.             IF Zahl > 9 THEN
  351.                RETURN 2;
  352.  
  353.             ELSE
  354.                RETURN 1;
  355.             END (* IF Zahl > 9 *);
  356.          END (* IF Zahl > 99 *);
  357.       END (* IF Zahl > 999 *);
  358.    END (* IF Zahl > 9999 *);
  359. END (* Funktion *) AZiffern;
  360.  
  361. (* --------------------------------------------------------------------- *)
  362.  
  363. PROCEDURE DrawCross (rPort: RastPortPtr;
  364.                      x, y : INTEGER);
  365.  
  366.    (* zeichnet ein kleines Kreuz mit Mittelpunkt (x,y) *)
  367.  
  368.    BEGIN (* Prozedur DrawCross *)
  369.  
  370.    Move (rPort, x - 1, y);
  371.    Draw (rPort, x + 2, y);
  372.  
  373.    Move (rPort, x, y - 1);
  374.    Draw (rPort, x, y + 1);
  375.  
  376.    Move (rPort, x + 1, y - 1);
  377.    Draw (rPort, x + 1, y + 1);
  378. END DrawCross (* Prozedur *);
  379.  
  380. (* --------------------------------------------------------------------- *)
  381.  
  382. PROCEDURE Exponent (Wert: LONGREAL): BOOLEAN;
  383.  
  384.    (* entscheidet, ob Wert mit oder ohne Exponent ausgegeben wird    *)
  385.  
  386.    BEGIN (* Funktion Exponent *)
  387.  
  388.    Wert := ABS (Wert); (* Jetzt ist Wert >= 0.0 *)
  389.  
  390.    IF ((Wert < 1000.0) AND (Wert > 0.001)) OR (Wert = 0.0) THEN
  391.       RETURN FALSE;
  392.  
  393.    ELSE
  394.       RETURN TRUE;
  395.    END (* IF (Wert *);
  396. END Exponent (* Funktion *);
  397.  
  398. (* --------------------------------------------------------------------- *)
  399.  
  400. PROCEDURE GadgetAn (Gad    : GadgetPtr;
  401.                     Fenster: WindowPtr;
  402.                     Req    : RequesterPtr);
  403.  
  404.    (* schaltet ein Gadget an (etwas schneller als OnGadget allein) *)
  405.  
  406.    VAR NaechstesGad: GadgetPtr;
  407.  
  408.    (* ------------------------------------------------------------------ *)
  409.  
  410.    BEGIN (* Prozedur GadgetAn *)
  411.  
  412.    (* alle folgenden ausblenden *)
  413.    NaechstesGad := Gad^.nextGadget;
  414.    Gad^.nextGadget := NIL;
  415.  
  416.    (* einschalten *)
  417.    OnGadget (Gad, Fenster, Req);
  418.  
  419.    (* die folgenden wieder anhängen *)
  420.    Gad^.nextGadget := NaechstesGad;
  421.  
  422. END GadgetAn (* Prozedur *);
  423.  
  424. (* --------------------------------------------------------------------- *)
  425.  
  426. PROCEDURE GadgetAus (Gad    : GadgetPtr;
  427.                      Fenster: WindowPtr;
  428.                      Req    : RequesterPtr);
  429.  
  430.    (* schaltet Gadgets schneller aus als OffGadget allein... *)
  431.  
  432.    VAR NaechstesGad: GadgetPtr;
  433.  
  434.    (* ------------------------------------------------------------------ *)
  435.  
  436.    BEGIN (* Prozedur GadgetAus *)
  437.  
  438.    (* alle folgenden ausblenden *)
  439.    NaechstesGad := Gad^.nextGadget;
  440.    Gad^.nextGadget := NIL;
  441.  
  442.    (* ausschalten *)
  443.    OffGadget (Gad, Fenster, Req);
  444.  
  445.    (* die folgenden wieder anhängen *)
  446.    Gad^.nextGadget := NaechstesGad;
  447.  
  448. END GadgetAus (* Prozedur *);
  449.  
  450. (* --------------------------------------------------------------------- *)
  451.  
  452. PROCEDURE ImRastPort (element   : INTEGER;
  453.                       koordinate: Koordinate
  454.                      ): BOOLEAN;
  455.  
  456.    (* stellt fest, ob die Zeile/Spalte element im Rastport *)
  457.    (* GFenster^.rPort^ darstellbar ist                     *)
  458.  
  459.    BEGIN (* Funktion ImRastPort *)
  460.  
  461.    IF koordinate = x THEN
  462.       IF (element >= SpalteMin) AND (element <= (SpalteMax + SpalteMin)) THEN
  463.          RETURN TRUE;
  464.  
  465.       ELSE (* IF element *)
  466.          RETURN FALSE;
  467.       END (* IF (element *);
  468.  
  469.    ELSE (* IF koordiante *)
  470.       IF (element >= ZeileMin) AND (element <= (ZeileMax + ZeileMin)) THEN
  471.          RETURN TRUE;
  472.  
  473.       ELSE (* IF element *)
  474.          RETURN FALSE;
  475.       END (* IF (element *);
  476.    END (* IF koordinate *)
  477. END ImRastPort (* Funktion *);
  478.  
  479. (* --------------------------------------------------------------------- *)
  480.  
  481. PROCEDURE InitGerade (VAR Gerade: AGerade);
  482.  
  483.    (* initialisiert den Record Gerade *)
  484.  
  485.    BEGIN (* Prozedur InitGerade *)
  486.  
  487.    WITH Gerade DO
  488.       M := 0;
  489.       N := 0;
  490.       Groesse := 0;
  491.       Adresse := NIL;
  492.       Disk := FALSE;
  493.  
  494.       WITH Daten DO
  495.          A := 0.0;
  496.          B := 0.0;
  497.          XM := 0.0;
  498.          YM := 0.0;
  499.          XS := 0.0;
  500.          YS := 0.0;
  501.          GS := 0.0;
  502.          AS := 0.0;
  503.          BS := 0.0;
  504.          R := 0.0;
  505.       END (* WITH Daten *);
  506.  
  507.       BBekannt := FALSE;
  508.    END (* WITH Gerade *);
  509. END InitGerade (* Prozedur *);
  510.  
  511. (* --------------------------------------------------------------------- *)
  512.  
  513. PROCEDURE Laenge (Zahl: INTEGER): INTEGER;
  514.  
  515.    (* ermittelt die Anzahl der Stellen von Zahl ohne Vorzeichen *)
  516.  
  517.    BEGIN (* Funktion Laenge *)
  518.  
  519.    IF Zahl < 0 THEN
  520.       Zahl := - Zahl;
  521.    END (* IF Zahl *);
  522.  
  523.    IF Zahl < 10 THEN
  524.       RETURN 1;
  525.  
  526.    ELSE
  527.       IF Zahl < 100 THEN
  528.          RETURN 2;
  529.  
  530.       ELSE
  531.          IF Zahl < 1000 THEN
  532.             RETURN 3;
  533.  
  534.          ELSE
  535.             IF Zahl < 10000 THEN
  536.                RETURN 4;
  537.  
  538.             ELSE
  539.                RETURN 5;
  540.             END;
  541.          END;
  542.       END;
  543.    END;
  544. END Laenge (* Funktion *);
  545.  
  546. (* --------------------------------------------------------------------- *)
  547.  
  548. PROCEDURE MakeRequest (TextPos,
  549.                        TextNeg,
  550.                        ReqText : IntuiTextPtr;
  551.                        Fenster : WindowPtr;
  552.                        AnzGad  : CARDINAL     ): BOOLEAN;
  553.  
  554.    (* zeichnet einen Requester, wobei der Text automatisch zentriert *)
  555.    (* wird (ReqText^.leftEdge = 0 setzen!)                           *)
  556.  
  557.    VAR Req     : Requester;
  558.        ReqGad  : ARRAY [1..2] OF Gadget;
  559.        StrPtr,
  560.        StrPtr2 : POINTER TO ARRAY [0..80] OF CHAR;
  561.        Rahmen  : ARRAY [1..3] OF Border;
  562.        Ecken   : ARRAY [1..3], [1..10] OF INTEGER;
  563.        Width   : INTEGER;
  564.        ITextPtr: IntuiTextPtr;
  565.  
  566.        Nachricht: IntuiMessagePtr;
  567.        Flags    : IDCMPFlagSet;
  568.        AngGad   : GadgetPtr;
  569.        Erfolg   : BOOLEAN;
  570.  
  571.    (* ------------------------------------------------------------------ *)
  572.  
  573.    BEGIN (* Funktion MakeRequest *)
  574.  
  575.    (* Größe des Requesters *)
  576.    ITextPtr := ReqText;
  577.    StrPtr := ITextPtr^.iText;
  578.    Width := INTEGER (Length (StrPtr^)) * 10 + 10;
  579.  
  580.    WHILE ITextPtr^.nextText # NIL DO
  581.       ITextPtr := ITextPtr^.nextText;
  582.       StrPtr := ITextPtr^.iText;
  583.  
  584.       IF 10 * INTEGER (Length (StrPtr^)) + 10 > Width THEN
  585.          Width := 10 * INTEGER (Length (StrPtr^)) + 10;
  586.       END (* IF Length *);
  587.    END (* WHILE *);
  588.  
  589.    StrPtr := TextNeg^.iText;
  590.    StrPtr2 := TextPos^.iText;
  591.  
  592.    (* Sind die beiden (?) Gadgets zusammen länger als der Text? *)
  593.    IF AnzGad = 1 THEN
  594.       IF 10 * INTEGER (Length (StrPtr2^) + 10) > Width THEN
  595.          Width := 10 * INTEGER (Length (StrPtr2^) + 10);
  596.       END (* IF Length *);
  597.  
  598.    ELSE (* AnzGad = 2 *)
  599.       IF 10 * INTEGER (Length (StrPtr^) + Length (StrPtr2^) + 10) > Width
  600.          THEN
  601.          Width := 10 * INTEGER (Length (StrPtr^) + Length (StrPtr2^) + 10);
  602.       END (* IF Length *);
  603.    END (* IF AnzGad *);
  604.  
  605.    (* Rahmen um Requester *)
  606.    Ecken [3, 1] := 0;         Ecken [3,  2] := 0;
  607.    Ecken [3, 3] := Width - 1; Ecken [3,  4] := 0;
  608.    Ecken [3, 5] := Width - 1; Ecken [3,  6] := 79;
  609.    Ecken [3, 7] := 0;         Ecken [3,  8] := 79;
  610.    Ecken [3, 9] := 0;         Ecken [3, 10] := 0;
  611.  
  612.    WITH Rahmen [3] DO
  613.       leftEdge := 0;
  614.       topEdge := 0;
  615.       frontPen := 6;
  616.       backPen := 0;
  617.       drawMode := jam2;
  618.       count := 5;
  619.       xy := ADR (Ecken [3, 1]);
  620.       nextBorder := NIL;
  621.    END (* WITH Rahmen [2] *);
  622.  
  623.    (* Gadgets im Requester *)
  624.    IF AnzGad = 2 THEN
  625.       StrPtr := TextNeg^.iText;
  626.  
  627.       (* Rahmen drumherum *)
  628.       Ecken [2, 1] := -1;                        Ecken [2,  2] := -2;
  629.       Ecken [2, 3] := Length (StrPtr^) * 10 + 1; Ecken [2,  4] := -2;
  630.       Ecken [2, 5] := Length (StrPtr^) * 10 + 1; Ecken [2,  6] := 10;
  631.       Ecken [2, 7] := -1;                        Ecken [2,  8] := 10;
  632.       Ecken [2, 9] := -1;                        Ecken [2, 10] := -2;
  633.  
  634.       Rahmen [2] := Rahmen [3];
  635.       Rahmen [2].xy := ADR (Ecken [2, 1]);
  636.    END (* IF AnzGad *);
  637.  
  638.    StrPtr := TextPos^.iText;
  639.  
  640.    Ecken [1, 1] := -1;                        Ecken [1,  2] := -2;
  641.    Ecken [1, 3] := Length (StrPtr^) * 10 + 1; Ecken [1,  4] := -2;
  642.    Ecken [1, 5] := Length (StrPtr^) * 10 + 1; Ecken [1,  6] := 10;
  643.    Ecken [1, 7] := -1;                        Ecken [1,  8] := 10;
  644.    Ecken [1, 9] := -1;                        Ecken [1, 10] := -2;
  645.  
  646.    Rahmen [1] := Rahmen [3];
  647.    Rahmen [1].xy := ADR (Ecken [1, 1]);
  648.  
  649.    WITH ReqGad [2] DO
  650.       nextGadget := NIL;
  651.       width := Ecken [2, 3] - 1;
  652.       height := 9;
  653.       leftEdge := Width - 10 - width;
  654.       topEdge := 60;
  655.       flags := GadgetFlagSet {};
  656.       activation := ActivationFlagSet {relVerify, endGadget};
  657.       gadgetType := boolGadget + reqGadget;
  658.       gadgetRender := ADR (Rahmen [2]);
  659.       gadgetText := TextNeg;
  660.       mutualExclude := LONGSET {};
  661.       specialInfo := NIL;
  662.       gadgetID := 2;
  663.       userData := NIL;
  664.    END (* WITH ReqGad [2] *);
  665.  
  666.    ReqGad [1] := ReqGad [2];
  667.    ReqGad [1].width := Ecken [1, 3] - 1;
  668.  
  669.    IF AnzGad = 2 THEN
  670.       ReqGad [1].nextGadget := ADR (ReqGad [2]);
  671.       ReqGad [1].leftEdge := 10;
  672.  
  673.    ELSE (* IF AnzGad *)
  674.       ReqGad [1].nextGadget := NIL;
  675.       ReqGad [1].leftEdge := (Width - ReqGad [1].width) DIV 2;
  676.    END (* IF AnzGad *);
  677.  
  678.    ReqGad [1].gadgetRender := ADR (Rahmen [1]);
  679.    ReqGad [1].gadgetText := TextPos;
  680.    ReqGad [1].gadgetID := 1;
  681.  
  682.    (* der Requester *)
  683.    WITH Req DO
  684.       olderRequest := NIL;
  685.       leftEdge := (640 - Width) DIV 2;
  686.       topEdge := 55;
  687.       width := Width;
  688.       height := 80;
  689.       relLeft := 0;
  690.       relTop := 0;
  691.       reqGadget := ADR (ReqGad [1]);
  692.       reqBorder := ADR (Rahmen [3]);
  693.       reqText := ReqText;
  694.       flags := RequesterFlagSet {};
  695.       backFill := 4;
  696.       reqLayer := NIL;
  697.       imageBMap := NIL;
  698.    END (* WITH Req *);
  699.  
  700.    (* Text zentrieren *)
  701.    ITextPtr := Req.reqText;
  702.  
  703.    WHILE ITextPtr # NIL DO
  704.       StrPtr := ITextPtr^.iText;
  705.       ITextPtr^.leftEdge := (Width - 10 * INTEGER (Length (StrPtr^))) DIV 2;
  706.       ITextPtr := ITextPtr^.nextText;
  707.    END (* WHILE *);
  708.  
  709.    Erfolg := Request (ADR (Req), Fenster);
  710.  
  711.    Assert (Erfolg, ADR ("konnte Requester nicht öffnen!"));
  712.  
  713.    (* Requester abfragen *)
  714.    REPEAT
  715.       Flags := IDCMPFlagSet {};
  716.       AngGad := NIL;
  717.  
  718.       WaitPort (Req.rWindow^.userPort);
  719.       Nachricht := GetMsg (Req.rWindow^.userPort);
  720.  
  721.       IF Nachricht # NIL THEN
  722.          Flags := Nachricht^.class;
  723.          AngGad := Nachricht^.iAddress;
  724.          ReplyMsg (Nachricht);
  725.       END (* IF Nachricht # NIL *);
  726.    UNTIL AngGad # NIL;
  727.  
  728.    RETURN (AngGad^.gadgetID = 1);
  729. END (* Funktion *) MakeRequest;
  730.  
  731. (* --------------------------------------------------------------------- *)
  732.  
  733. PROCEDURE Positiv (Wert: LONGREAL;
  734.                    Null: BOOLEAN
  735.                   ): BOOLEAN;
  736.  
  737.    BEGIN (* Funktion Positiv *)
  738.  
  739.    IF Null THEN
  740.       RETURN (Wert >= 0.0);
  741.  
  742.    ELSE (* IF Null *)
  743.       RETURN (Wert > 0.0);
  744.    END (* IF Null *);
  745. END Positiv (* Funktion *);
  746.  
  747. (* --------------------------------------------------------------------- *)
  748.  
  749. PROCEDURE PrintText (Fenster   : WindowPtr;
  750.                      Text      : ARRAY OF CHAR; (* <-> PrintIText *)
  751.                      LeftOffset: INTEGER;
  752.                      TopOffset : INTEGER);
  753.  
  754.    (* ein bequemes PrintIText *)
  755.  
  756.    VAR IText: IntuiText;
  757.  
  758.    (* ------------------------------------------------------------------ *)
  759.  
  760.    BEGIN (* PROCEDURE PrintText *)
  761.  
  762.    WITH IText DO
  763.       frontPen := Fenster^.blockPen;
  764.       backPen := Fenster^.detailPen;
  765.       drawMode := jam2;
  766.       leftEdge := 0;
  767.       topEdge := 0;
  768.       iTextFont := NIL;
  769.       iText := ADR (Text);
  770.       nextText := NIL;
  771.    END (* WITH iText *);
  772.  
  773.    PrintIText (Fenster^.rPort, ADR (IText), LeftOffset, TopOffset);
  774. END PrintText (* PROCEDURE *);
  775.  
  776. (* --------------------------------------------------------------------- *)
  777.  
  778. PROCEDURE RefreshGadList (Gad    : GadgetPtr;
  779.                           Fenster: WindowPtr;
  780.                           Req    : RequesterPtr;
  781.                           Anz    : INTEGER      );
  782.  
  783.    (* erledigt das Refreshen etwas schneller... *)
  784.  
  785.    VAR LetztesGad,
  786.        NaechstesGad: GadgetPtr;
  787.        i           : INTEGER;
  788.  
  789.    (* ------------------------------------------------------------------ *)
  790.  
  791.    BEGIN (* Prozedur RefreshGadList *)
  792.  
  793.    (* letztes zu refreshendes Gadget finden *)
  794.    LetztesGad := Gad;
  795.  
  796.    FOR i := 1 TO (Anz - 1) DO
  797.       LetztesGad := LetztesGad^.nextGadget;
  798.    END (* FOR i *);
  799.  
  800.    (* alle nicht zu refreshenden Gadgets abhängen... *)
  801.    NaechstesGad := LetztesGad^.nextGadget;
  802.    LetztesGad^.nextGadget := NIL;
  803.  
  804.    (* refreshen... *)
  805.    RefreshGList (Gad, Fenster, Req, Anz);
  806.  
  807.    (* ...und wieder anfügen *)
  808.    LetztesGad^.nextGadget := NaechstesGad;
  809.  
  810. END RefreshGadList (* Prozedur *);
  811.  
  812. (* --------------------------------------------------------------------- *)
  813.  
  814. PROCEDURE RUmGadget (Box    : Gadget;
  815.                      Mod    : AnAus;
  816.                      Fenster: WindowPtr);
  817.  
  818.    (* zeichnet oder löscht einen Rahmen um eines der 6 linken        *)
  819.    (* Toggleselectgadgets                                            *)
  820.  
  821.    VAR Ecken : ARRAY [1..10] OF INTEGER;
  822.        Rahmen: Border;
  823.  
  824.    (* ------------------------------------------------------------------ *)
  825.  
  826.    BEGIN (* Prozedur RUmGadget *)
  827.  
  828.    Ecken [1] := -3;  Ecken [ 2] := -3;
  829.    Ecken [3] := 164; Ecken [ 4] := -3;
  830.    Ecken [5] := 164; Ecken [ 6] := 12;
  831.    Ecken [7] := -3;  Ecken [ 8] := 12;
  832.    Ecken [9] := -3;  Ecken [10] := -3;
  833.  
  834.    WITH Rahmen DO
  835.       leftEdge := Box.leftEdge;
  836.       topEdge := Box.topEdge;
  837.  
  838.       IF Mod = An THEN
  839.          frontPen := 7;
  840.       ELSE (* IF Mod *)
  841.          frontPen := 0;
  842.       END (* IF Mod *);
  843.  
  844.       backPen := 0;
  845.       drawMode := jam2;
  846.       count := 5;
  847.       xy := ADR (Ecken [1]);
  848.       nextBorder := NIL;
  849.    END (* WITH Rahmen *);
  850.  
  851.    DrawBorder (Fenster^.rPort, ADR (Rahmen), 0, 0);
  852. END (* Prozedur *) RUmGadget;
  853.  
  854. (* --------------------------------------------------------------------- *)
  855.  
  856. PROCEDURE Schreibe (Datei     : FileHandlePtr;
  857.                     String    : ARRAY OF CHAR;
  858.                     Leerzeilen: CARDINAL      );
  859.  
  860.    (* Schreibt den String STRING in die Ausgabedatei und fügt eine   *)
  861.    (* anzugebende Anzahl Leerzeilen dahinter ein.                    *)
  862.  
  863.    VAR Error: LONGINT;
  864.        i    : CARDINAL;
  865.        EOL  : CHAR;
  866.  
  867.    (* ------------------------------------------------------------------ *)
  868.  
  869.    BEGIN (* Prozedur Schreibe *)
  870.  
  871.    EOL := eol; (* damit das Ding eine Adresse bekommt und der        *)
  872.                (* Compiler nicht meckert!                            *)
  873.  
  874.    Error := Write (Datei, ADR (String), Length (String));
  875.  
  876.    FOR i := 0 TO Leerzeilen DO
  877.       Error := Write (Datei, ADR (EOL), 1);
  878.    END (* FOR i *);
  879. END Schreibe (* Prozedur *);
  880.  
  881. (* --------------------------------------------------------------------- *)
  882.  
  883. PROCEDURE Spalte (XWert: LONGREAL): INTEGER;
  884.  
  885.    (* ermittelt die Spalte in der Grafik für einen Punkt *)
  886.  
  887.    (* globale Variablen: XMin, XPixelBr *)
  888.  
  889.    BEGIN (* Funktion Spalte *)
  890.  
  891.    RETURN INTEGER ((XWert - XMin) / XPixelBr) + SpalteMin;
  892. END Spalte (* Funktion *);
  893.  
  894. (* --------------------------------------------------------------------- *)
  895.  
  896. PROCEDURE Zeile (YWert: LONGREAL): INTEGER;
  897.  
  898.    (* ermittelt die Zeile in der Grafik für einen Punkt *)
  899.  
  900.    (* globale Variablen: YMax, YPixelBr *)
  901.  
  902.    BEGIN (* Funktion Zeile *)
  903.  
  904.    RETURN INTEGER ((YMax - YWert) / YPixelBr) + ZeileMin;
  905. END Zeile (* Funktion *);
  906.  
  907. (* --------------------------------------------------------------------- *)
  908. (* --------------------------------------------------------------------- *)
  909.  
  910. BEGIN (* Modul Ausgleichsgerade *)
  911.  
  912. (* zu Beginn... *)
  913. Font := NIL;
  914. BildReq := NIL;
  915. Bildschirm := NIL;
  916. BFenster := NIL;
  917. DFenster := NIL;
  918. GFenster := NIL;
  919. Datei := NIL;
  920. Programmende := FALSE;
  921. ErstesMal := TRUE;
  922.  
  923. (* IntuiText für Requester initialisieren *)
  924. WITH ReqText [4] DO
  925.    (* Neg-Gadget *)
  926.    frontPen := 3;
  927.    backPen := 4;
  928.    drawMode := jam2;
  929.    leftEdge := 0;
  930.    topEdge := 0;
  931.    iTextFont := NIL;
  932.    iText := NIL;
  933.    nextText := NIL;
  934. END (* WITH ReqText [4] *);
  935.  
  936. (* Pos-Gadget *)
  937. ReqText [3] := ReqText [4];
  938.  
  939. (* Text, 2. Zeile *)
  940. ReqText [2] := ReqText [3];
  941. ReqText [2].topEdge := 40;
  942.  
  943. (* Text, 1. Zeile *)
  944. ReqText [1] := ReqText [2];
  945. ReqText [1].topEdge := 20;
  946. ReqText [1].nextText := ADR (ReqText [2]);
  947.  
  948. (* Gerade initialisieren *)
  949. InitGerade (Gerade);
  950.  
  951. (* der Font *)
  952. WITH Attr DO
  953.    name := ADR (FontName);
  954.    ySize := FontHoehe;
  955.    style := FontStyleSet {};
  956.    flags := FontFlagSet {};
  957. END (* WITH Attr *);
  958.  
  959. Font := OpenFont (ADR (Attr));
  960.  
  961. (* Variablenfelder initialisieren *)
  962. (* die ganzen Texte *)
  963. WITH IText [24] DO
  964.    frontPen := 1;
  965.    backPen := 0;
  966.    drawMode := jam2;
  967.    leftEdge := 220;
  968.    topEdge := 80;
  969.    iTextFont := ADR (Attr);
  970.    iText := ADR ("Y(X=0):");
  971.    nextText := NIL;
  972. END (* WITH IText [24] *);
  973.  
  974. IText [23] := IText [24];
  975. IText [23].leftEdge := 5;
  976. IText [23].topEdge := 1;
  977. IText [23].iText := ADR ("n. bek.");
  978.  
  979. ILeer [36] := IText [24];
  980. ILeer [36].leftEdge := 0;
  981. ILeer [36].topEdge := 1;
  982. ILeer [36].iText := ADR (Space8);
  983. ILeer [36].nextText := ADR (IText [23]);
  984.  
  985. ILeer [35] := ILeer [36];
  986. ILeer [35].topEdge := 0;
  987. ILeer [35].nextText := ADR (ILeer [36]);
  988.  
  989. IText [22] := IText [23];
  990. IText [22].iText := ADR ("bekannt");
  991.  
  992. ILeer [34] := ILeer [36];
  993. ILeer [34].nextText := ADR (IText [22]);
  994.  
  995. ILeer [33] := ILeer [35];
  996. ILeer [33].nextText := ADR (ILeer [34]);
  997.  
  998. IText [21] := IText [22];
  999. IText [21].leftEdge := 220;
  1000. IText [21].topEdge := 20;
  1001. IText [21].iText := ADR ("Anzahl der Paare:");
  1002. IText [21].nextText := ADR (IText [24]);
  1003.  
  1004. IText [20] := IText [21];
  1005. IText [20].topEdge := 40;
  1006. IText [20].iText := ADR ("Paar Nr.");
  1007. IText [20].nextText := ADR (IText [21]);
  1008.  
  1009. IText [19] := IText [20];
  1010. IText [19].leftEdge := 0;
  1011. IText [19].topEdge := 1;
  1012. IText [19].iText := ADR (" + ");
  1013. IText [19].nextText := NIL;
  1014.  
  1015. ILeer [32] := ILeer [34];
  1016. ILeer [32].iText := ADR (Space3);
  1017. ILeer [32].nextText := ADR (IText [19]);
  1018.  
  1019. ILeer [31] := ILeer [33];
  1020. ILeer [31].iText := ADR (Space3);
  1021. ILeer [31].nextText := ADR (ILeer [32]);
  1022.  
  1023. IText [18] := IText [19];
  1024. IText [18].iText := ADR (" - ");
  1025.  
  1026. ILeer [30] := ILeer [32];
  1027. ILeer [30].nextText := ADR (IText [18]);
  1028.  
  1029. ILeer [29] := ILeer [31];
  1030. ILeer [29].nextText := ADR (ILeer [30]);
  1031.  
  1032. IText [17] := IText [18];
  1033. IText [17].iText := ADR ("10+");
  1034.  
  1035. ILeer [28] := ILeer [30];
  1036. ILeer [28].nextText := ADR (IText [17]);
  1037.  
  1038. ILeer [27] := ILeer [29];
  1039. ILeer [27].nextText := ADR (ILeer [28]);
  1040.  
  1041. IText [16] := IText [17];
  1042. IText [16].iText := ADR ("10-");
  1043.  
  1044. ILeer [26] := ILeer [28];
  1045. ILeer [26].nextText := ADR (IText [16]);
  1046.  
  1047. ILeer [25] := ILeer [27];
  1048. ILeer [25].nextText := ADR (ILeer [26]);
  1049.  
  1050. IText [15] := IText [16];
  1051. IText [15].leftEdge := 5;
  1052. IText [15].iText := ADR ("Ausgleichsgerade berechnen");
  1053.  
  1054. ILeer [24] := ILeer [26];
  1055. ILeer [24].iText := ADR (Space27);
  1056. ILeer [24].nextText := ADR (IText [15]);
  1057.  
  1058. ILeer [23] := ILeer [25];
  1059. ILeer [23].iText := ADR (Space27);
  1060. ILeer [23].nextText := ADR (ILeer [24]);
  1061.  
  1062. IText [14] := IText [15];
  1063. IText [14].leftEdge := 5;
  1064. IText [14].iText := ADR ("Gerade zeichnen");
  1065.  
  1066. ILeer [22] := ILeer [24];
  1067. ILeer [22].iText := ADR (Space16);
  1068. ILeer [22].nextText := ADR (IText [14]);
  1069.  
  1070. ILeer [21] := ILeer [23];
  1071. ILeer [21].iText := ADR (Space16);
  1072. ILeer [21].nextText := ADR (ILeer [22]);
  1073.  
  1074. IText [13] := IText [14];
  1075. IText [13].leftEdge := 4;
  1076. IText [13].iText := ADR (" E N D E ");
  1077.  
  1078. ILeer [20] := ILeer [22];
  1079. ILeer [20].iText := ADR (Space10);
  1080. ILeer [20].nextText := ADR (IText [13]);
  1081.  
  1082. ILeer [19] := ILeer [21];
  1083. ILeer [19].iText := ADR (Space10);
  1084. ILeer [19].nextText := ADR (ILeer [20]);
  1085.  
  1086. IText [12] := IText [13];
  1087. IText [12].iText := ADR ("Speichern");
  1088.  
  1089. ILeer [18] := ILeer [20];
  1090. ILeer [18].nextText := ADR (IText [12]);
  1091.  
  1092. ILeer [17] := ILeer [19];
  1093. ILeer [17].nextText := ADR (ILeer [18]);
  1094.  
  1095. IText [11] := IText [13];
  1096. IText [11].iText := ADR ("  Laden  ");
  1097.  
  1098. ILeer [16] := ILeer [18];
  1099. ILeer [16].nextText := ADR (IText [11]);
  1100.  
  1101. ILeer [15] := ILeer [17];
  1102. ILeer [15].nextText := ADR (ILeer [16]);
  1103.  
  1104. IText [10] := IText [11];
  1105. IText [10].leftEdge := 0;
  1106. IText [10].iText := ADR (" Drucken ");
  1107.  
  1108. ILeer [14] := ILeer [16];
  1109. ILeer [14].iText := ADR (Space9);
  1110. ILeer [14].nextText := ADR (IText [10]);
  1111.  
  1112. ILeer [13] := ILeer [15];
  1113. ILeer [13].iText := ADR (Space9);
  1114. ILeer [13].nextText := ADR (ILeer [14]);
  1115.  
  1116. IText [9] := IText [10];
  1117. IText [9].iText := ADR (" Seitenvorschub ");
  1118.  
  1119. ILeer [12] := ILeer [14];
  1120. ILeer [12].iText := ADR (Space16);
  1121. ILeer [12].nextText := ADR (IText [9]);
  1122.  
  1123. ILeer [11] := ILeer [13];
  1124. ILeer [11].iText := ADR (Space16);
  1125. ILeer [11].nextText := ADR (ILeer [12]);
  1126.  
  1127. IText [8] := IText [9];
  1128. IText [8].iText := ADR ("Ausgleichsgerade");
  1129.  
  1130. ILeer [10] := ILeer [12];
  1131. ILeer [10].nextText := ADR (IText [8]);
  1132.  
  1133. ILeer [9] := ILeer [11];
  1134. ILeer [9].nextText := ADR (ILeer [10]);
  1135.  
  1136. IText [7] := IText [8];
  1137. IText [7].iText := ADR (" Seitenvorschub ");
  1138.  
  1139. ILeer [8] := ILeer [10];
  1140. ILeer [8].nextText := ADR (IText [7]);
  1141.  
  1142. ILeer [7] := ILeer [9];
  1143. ILeer [7].nextText := ADR (ILeer [8]);
  1144.  
  1145. IText [6] := IText [7];
  1146. IText [6].iText := ADR ("Daten der Gerade");
  1147.  
  1148. ILeer [6] := ILeer [8];
  1149. ILeer [6].nextText := ADR (IText [6]);
  1150.  
  1151. ILeer [5] := ILeer [7];
  1152. ILeer [5].nextText := ADR (ILeer [6]);
  1153.  
  1154. IText [5] := IText [6];
  1155. IText [5].iText := ADR (" Seitenvorschub ");
  1156.  
  1157. ILeer [4] := ILeer [6];
  1158. ILeer [4].nextText := ADR (IText [5]);
  1159.  
  1160. ILeer [3] := ILeer [5];
  1161. ILeer [3].nextText := ADR (ILeer [4]);
  1162.  
  1163. IText [4] := IText [5];
  1164. IText [4].iText := ADR ("   Wertepaare   ");
  1165.  
  1166. ILeer [2] := ILeer [4];
  1167. ILeer [2].nextText := ADR (IText [4]);
  1168.  
  1169. ILeer [1] := ILeer [3];
  1170. ILeer [1].nextText := ADR (ILeer [2]);
  1171.  
  1172. IText [3] := IText [4];
  1173. IText [3].topEdge := 20;
  1174. IText [3].leftEdge := 50;
  1175. IText [3].iText := ADR ("Ausdruck:");
  1176. IText [3].nextText := ADR (IText [20]);
  1177.  
  1178. IText [2] := IText [3];
  1179. IText [2].topEdge := 60;
  1180. IText [2].leftEdge := 220;
  1181. IText [2].iText := ADR ("X:");
  1182. IText [2].nextText := ADR (IText [3]);
  1183.  
  1184. IText [1] := IText [2];
  1185. IText [1].leftEdge := 410;
  1186. IText [1].iText := ADR ("Y:");
  1187. IText [1].nextText := ADR (IText [2]);
  1188.  
  1189. (* Stringinfos für 2× Longinteger- und 3× String-Gadgets *)
  1190. XZahl := "";
  1191. UXZahl := XZahl;
  1192. YZahl := "";
  1193. UYZahl := YZahl;
  1194. YVonX := "0.0";
  1195. UYVonX := YVonX;
  1196. SPaarNr := "0";
  1197. USPaarNr := SPaarNr;
  1198. SMaxPaare := "0";
  1199. USMaxPaare := SMaxPaare;
  1200.  
  1201. WITH SInfo [5] DO
  1202.    buffer := ADR (YVonX);
  1203.    undoBuffer := ADR (UYVonX);
  1204.    bufferPos := 0;
  1205.    maxChars := 16;
  1206.    dispPos := 0;
  1207.    longInt := 0;
  1208.    altKeyMap := NIL;
  1209. END (* WITH SInfo [5] *);
  1210.  
  1211. SInfo [4] := SInfo [5];
  1212. SInfo [4].buffer := ADR (XZahl);
  1213. SInfo [4].undoBuffer := ADR (UXZahl);
  1214.  
  1215. SInfo [3] := SInfo [4];
  1216. SInfo [3].buffer := ADR (YZahl);
  1217. SInfo [3].undoBuffer := ADR (UYZahl);
  1218.  
  1219. SInfo [2] := SInfo [3];
  1220. SInfo [2].buffer := ADR (SPaarNr);
  1221. SInfo [2].undoBuffer := ADR (USPaarNr);
  1222. SInfo [2].maxChars := 6;
  1223.  
  1224. SInfo [1] := SInfo [2];
  1225. SInfo [1].buffer := ADR (SMaxPaare);
  1226. SInfo [1].undoBuffer := ADR (USMaxPaare);
  1227.  
  1228. (* Rahmen *)
  1229. (* der große um Ausdruck *)
  1230. Ecken [1, 1] := 0;   Ecken [1,  2] := 0;
  1231. Ecken [1, 3] := 175; Ecken [1,  4] := 0;
  1232. Ecken [1, 5] := 175; Ecken [1,  6] := 140;
  1233. Ecken [1, 7] := 0;   Ecken [1,  8] := 140;
  1234. Ecken [1, 9] := 0;   Ecken [1, 10] := 0;
  1235.  
  1236. WITH Rahmen [1] DO
  1237.    leftEdge := 5;
  1238.    topEdge := 15;
  1239.    frontPen := 7;
  1240.    backPen := 0;
  1241.    drawMode := jam2;
  1242.    count := 5;
  1243.    xy := ADR (Ecken [1, 1]);
  1244.    nextBorder := NIL;
  1245. END (* WITH Rahmen [1] *);
  1246.  
  1247. (* Gadgets innerhalb des Ausdruck-Rahmens *)
  1248. Ecken [2, 1] := -1;  Ecken [2,  2] := -1;
  1249. Ecken [2, 3] := 160; Ecken [2,  4] := -1;
  1250. Ecken [2, 5] := 160; Ecken [2,  6] := 10;
  1251. Ecken [2, 7] := -1;  Ecken [2,  8] := 10;
  1252. Ecken [2, 9] := -1;  Ecken [2, 10] := -1;
  1253.  
  1254. Rahmen [2] := Rahmen [1];
  1255. Rahmen [2].leftEdge := 0;
  1256. Rahmen [2].topEdge := 0;
  1257. Rahmen [2].xy := ADR (Ecken [2, 1]);
  1258.  
  1259. (* Rahmen um DRUCKEN *)
  1260. Ecken [3, 1] := -1; Ecken [3,  2] := -1;
  1261. Ecken [3, 3] := 91; Ecken [3,  4] := -1;
  1262. Ecken [3, 5] := 91; Ecken [3,  6] := 10;
  1263. Ecken [3, 7] := -1; Ecken [3,  8] := 10;
  1264. Ecken [3, 9] := -1; Ecken [3, 10] := -1;
  1265.  
  1266. Rahmen [3] := Rahmen [2];
  1267. Rahmen [3].xy := ADR (Ecken [3, 1]);
  1268.  
  1269. (* Rahmen um LONGINT-Gadgets *)
  1270. Ecken [4, 1] := -1; Ecken [4,  2] := -2;
  1271. Ecken [4, 3] := 60; Ecken [4,  4] := -2;
  1272. Ecken [4, 5] := 60; Ecken [4,  6] := 10;
  1273. Ecken [4, 7] := -1; Ecken [4,  8] := 10;
  1274. Ecken [4, 9] := -1; Ecken [4, 10] := -2;
  1275.  
  1276. Rahmen [4] := Rahmen [3];
  1277. Rahmen [4].xy := ADR (Ecken [4, 1]);
  1278.  
  1279. (* Rahmen um String (LONGREAL) -Gadgets *)
  1280. Ecken [5, 1] :=  -1; Ecken [5,  2] := -2;
  1281. Ecken [5, 3] := 150; Ecken [5,  4] := -2;
  1282. Ecken [5, 5] := 150; Ecken [5,  6] := 10;
  1283. Ecken [5, 7] :=  -1; Ecken [5,  8] := 10;
  1284. Ecken [5, 9] :=  -1; Ecken [5, 10] := -2;
  1285.  
  1286. Rahmen [5] := Rahmen [4];
  1287. Rahmen [5].xy := ADR (Ecken [5, 1]);
  1288.  
  1289. (* senkrechte und waagrechte Linie (nachträglich geändert) *)
  1290. Ecken [6, 1] := 195; Ecken [6,  2] :=  20;
  1291. Ecken [6, 3] := 195; Ecken [6,  4] := 180;
  1292. Ecken [6, 5] := 195; Ecken [6,  6] := 160;
  1293. Ecken [6, 7] := 620; Ecken [6,  8] := 160;
  1294. Ecken [6, 9] := 620; Ecken [6, 10] := 160;
  1295.  
  1296. Rahmen [6] := Rahmen [5];
  1297. Rahmen [6].count := 4;
  1298. Rahmen [6].xy := ADR (Ecken [6, 1]);
  1299. Rahmen [6].nextBorder := ADR (Rahmen [1]);
  1300.  
  1301. (* Rahmen um 10+ und 10- und + und -*)
  1302. Ecken [7, 1] := -1; Ecken [7,  2] := -1;
  1303. Ecken [7, 3] := 31; Ecken [7,  4] := -1;
  1304. Ecken [7, 5] := 31; Ecken [7,  6] := 10;
  1305. Ecken [7, 7] := -1; Ecken [7,  8] := 10;
  1306. Ecken [7, 9] := -1; Ecken [7, 10] := -1;
  1307.  
  1308. Rahmen [7] := Rahmen [5];
  1309. Rahmen [7].xy := ADR (Ecken [7, 1]);
  1310.  
  1311. (* Rahmen um Eingabefeld rechts oben *)
  1312. Ecken [8, 1] := 0;   Ecken [8,  2] := 0;
  1313. Ecken [8, 3] := 424; Ecken [8,  4] := 0;
  1314. Ecken [8, 5] := 424; Ecken [8,  6] := 80;
  1315. Ecken [8, 7] := 0;   Ecken [8,  8] := 80;
  1316. Ecken [8, 9] := 0;   Ecken [8, 10] := 0;
  1317.  
  1318. Rahmen [8] := Rahmen [1];
  1319. Rahmen [8].leftEdge := 210;
  1320. Rahmen [8].xy := ADR (Ecken [8, 1]);
  1321. Rahmen [8].nextBorder := ADR (Rahmen [6]);
  1322.  
  1323. (* Rahmen um Ausgleichsgerade berechnen *)
  1324. Ecken [9, 1] :=  -1; Ecken [9,  2] := -1;
  1325. Ecken [9, 3] := 270; Ecken [9,  4] := -1;
  1326. Ecken [9, 5] := 270; Ecken [9,  6] := 10;
  1327. Ecken [9, 7] :=  -1; Ecken [9,  8] := 10;
  1328. Ecken [9, 9] :=  -1; Ecken [9, 10] := -1;
  1329.  
  1330. Rahmen [9] := Rahmen [7];
  1331. Rahmen [9].xy := ADR (Ecken [9, 1]);
  1332.  
  1333. (* Rahmen um Gerade zeichnen *)
  1334. Ecken [10,  1] :=  -1; Ecken [10,  2] := -1;
  1335. Ecken [10,  3] := 160; Ecken [10,  4] := -1;
  1336. Ecken [10,  5] := 160; Ecken [10,  6] := 10;
  1337. Ecken [10,  7] :=  -1; Ecken [10,  8] := 10;
  1338. Ecken [10,  9] :=  -1; Ecken [10, 10] := -1;
  1339.  
  1340. Rahmen [10] := Rahmen [9];
  1341. Rahmen [10].xy := ADR (Ecken [10, 1]);
  1342.  
  1343. (* Rahmen um Laden, Speichern, E N D E *)
  1344. Ecken [11, 1] :=  -1; Ecken [11,  2] := -1;
  1345. Ecken [11, 3] := 100; Ecken [11,  4] := -1;
  1346. Ecken [11, 5] := 100; Ecken [11,  6] := 10;
  1347. Ecken [11, 7] :=  -1; Ecken [11,  8] := 10;
  1348. Ecken [11, 9] :=  -1; Ecken [11, 10] := -1;
  1349.  
  1350. Rahmen [11] := Rahmen [10];
  1351. Rahmen [11].xy := ADR (Ecken [11, 1]);
  1352.  
  1353. (* Rahmen um bekannt, nicht bekannt *)
  1354. Ecken [12, 1] := -1; Ecken [12,  2] := -1;
  1355. Ecken [12, 3] := 80; Ecken [12,  4] := -1;
  1356. Ecken [12, 5] := 80; Ecken [12,  6] := 10;
  1357. Ecken [12, 7] := -1; Ecken [12,  8] := 10;
  1358. Ecken [12, 9] := -1; Ecken [12, 10] := -1;
  1359.  
  1360. Rahmen [12] := Rahmen [11];
  1361. Rahmen [12].xy := ADR (Ecken [12, 1]);
  1362.  
  1363. (* nicht bekannt *)
  1364. WITH Box [23] DO
  1365.    nextGadget := NIL;
  1366.    leftEdge := 548;
  1367.    topEdge := 80;
  1368.    width := 80;
  1369.    height := 10;
  1370.    flags := GadgetFlagSet {gadgDisabled};
  1371.    activation := ActivationFlagSet {relVerify, toggleSelect};
  1372.    gadgetType := boolGadget;
  1373.    gadgetRender := ADR (Rahmen [12]);
  1374.    selectRender := NIL;
  1375.    gadgetText := ADR (ILeer [35]);
  1376.    mutualExclude := LONGSET {};
  1377.    specialInfo := NIL;
  1378.    gadgetID := 23;
  1379.    userData := NIL;
  1380. END (* WITH Box [23] *);
  1381.  
  1382. (* bekannt *)
  1383. Box [22] := Box [23];
  1384. Box [22].nextGadget := ADR (Box [23]);
  1385. Box [22].leftEdge := 458;
  1386. Box [22].gadgetText := ADR (ILeer [33]);
  1387. Box [22].gadgetID := 22;
  1388.  
  1389. (* Wert für Y (X=0) *)
  1390. Box [21] := Box [22];
  1391.  
  1392. WITH Box [21] DO
  1393.    nextGadget := ADR (Box [22]);
  1394.    leftEdge := 294;
  1395.    width := 150;
  1396.    height := 9;
  1397.    activation := ActivationFlagSet {relVerify, stringRight};
  1398.    gadgetRender := ADR (Rahmen [5]);
  1399.    gadgetType := strGadget;
  1400.    gadgetText := NIL;
  1401.    specialInfo := ADR (SInfo [5]);
  1402.    gadgetID := 21;
  1403. END (* WITH Box [21] *);
  1404.  
  1405. (* E N D E *)
  1406. Box [20] := Box [22];
  1407. Box [20].nextGadget := ADR (Box [21]);
  1408. Box [20].leftEdge := 510;
  1409. Box [20].topEdge := 170;
  1410. Box [20].width := 100;
  1411. Box [20].activation := ActivationFlagSet {relVerify};
  1412. Box [20].gadgetRender := ADR (Rahmen [11]);
  1413. Box [20].gadgetText := ADR (ILeer [19]);
  1414. Box [20].gadgetID := 20;
  1415.  
  1416. (* Speichern *)
  1417. Box [19] := Box [20];
  1418. Box [19].nextGadget := ADR (Box [20]);
  1419. Box [19].leftEdge := 365;
  1420. Box [19].gadgetText := ADR (ILeer [17]);
  1421. Box [19].gadgetID := 19;
  1422.  
  1423. (* Laden *)
  1424. Box [18] := Box [19];
  1425. Box [18].nextGadget := ADR (Box [19]);
  1426. Box [18].leftEdge := 221;
  1427. Box [18].gadgetText := ADR (ILeer [15]);
  1428. Box [18].gadgetID := 18;
  1429.  
  1430. (* DRUCKEN *)
  1431. Box [17] := Box [18];
  1432. Box [17].nextGadget := ADR (Box [18]);
  1433. Box [17].leftEdge := 45;
  1434. Box [17].width := 90;
  1435. Box [17].gadgetRender := ADR (Rahmen [3]);
  1436. Box [17].gadgetText := ADR (ILeer [13]);
  1437. Box [17].gadgetID := 17;
  1438.  
  1439. (* Seitenvorschub *)
  1440. Box [16] := Box [17];
  1441. Box [16].nextGadget := ADR (Box [17]);
  1442. Box [16].topEdge := 140;
  1443. Box [16].leftEdge := 13;
  1444. Box [16].width := 160;
  1445. Box [16].activation := ActivationFlagSet {relVerify, toggleSelect};
  1446. Box [16].gadgetRender := ADR (Rahmen [2]);
  1447. Box [16].gadgetText := ADR (ILeer [11]);
  1448. Box [16].gadgetID := 16;
  1449.  
  1450. (* Ausgleichsgerade *)
  1451. Box [15] := Box [16];
  1452. Box [15].nextGadget := ADR (Box [16]);
  1453. Box [15].topEdge := 120;
  1454. Box [15].gadgetText := ADR (ILeer [9]);
  1455. Box [15].gadgetID := 15;
  1456.  
  1457. (* Seitenvorschub *)
  1458. Box [14] := Box [15];
  1459. Box [14].nextGadget := ADR (Box [15]);
  1460. Box [14].topEdge := 100;
  1461. Box [14].gadgetText := ADR (ILeer [7]);
  1462. Box [14].gadgetID := 14;
  1463.  
  1464. (* Daten der Gerade *)
  1465. Box [13] := Box [14];
  1466. Box [13].nextGadget := ADR (Box [14]);
  1467. Box [13].topEdge := 80;
  1468. Box [13].gadgetText := ADR (ILeer [5]);
  1469. Box [13].gadgetID := 13;
  1470.  
  1471. (* Seitenvorschub *)
  1472. Box [12] := Box [13];
  1473. Box [12].nextGadget := ADR (Box [13]);
  1474. Box [12].topEdge := 60;
  1475. Box [12].gadgetText := ADR (ILeer [3]);
  1476. Box [12].gadgetID := 12;
  1477.  
  1478. (* Wertepaare *)
  1479. Box [11] := Box [12];
  1480. Box [11].nextGadget := ADR (Box [12]);
  1481. Box [11].topEdge := 40;
  1482. Box [11].gadgetText := ADR (ILeer [1]);
  1483. Box [11].gadgetID := 11;
  1484.  
  1485. (* Gerade zeichnen *)
  1486. Box [10] := Box [17];
  1487. Box [10].nextGadget := ADR (Box [11]);
  1488. Box [10].topEdge := 140;
  1489. Box [10].leftEdge := 221;
  1490. Box [10].width := 160;
  1491. Box [10].gadgetRender := ADR (Rahmen [10]);
  1492. Box [10].gadgetText := ADR (ILeer [21]);
  1493. Box [10].gadgetID := 10;
  1494.  
  1495. (* Ausgleichsgerade berechnen *)
  1496. Box [9] := Box [10];
  1497. Box [9].nextGadget := ADR (Box [10]);
  1498. Box [9].topEdge := 120;
  1499. Box [9].width := 270;
  1500. Box [9].gadgetRender := ADR (Rahmen [9]);
  1501. Box [9].gadgetText := ADR (ILeer [23]);
  1502. Box [9].gadgetID := 9;
  1503.  
  1504. (* Wert Y: *)
  1505. Box [8] := Box [21];
  1506. Box [8].nextGadget := ADR (Box [9]);
  1507. Box [8].topEdge := 60;
  1508. Box [8].leftEdge := 435;
  1509. Box [8].width := 150;
  1510. Box [8].gadgetRender := ADR (Rahmen [5]);
  1511. Box [8].specialInfo := ADR (SInfo [3]);
  1512. Box [8].gadgetID := 8;
  1513.  
  1514. (* Wert X: *)
  1515. Box [7] := Box [8];
  1516. Box [7].nextGadget := ADR (Box [8]);
  1517. Box [7].leftEdge := 245;
  1518. Box [7].specialInfo := ADR (SInfo [4]);
  1519. Box [7].gadgetID := 7;
  1520.  
  1521. (* 10- *)
  1522. Box [6] := Box [9];
  1523. Box [6].nextGadget := ADR (Box [7]);
  1524. Box [6].leftEdge := 590;
  1525. Box [6].topEdge := 40;
  1526. Box [6].width := 30;
  1527. Box [6].gadgetRender := ADR (Rahmen [7]);
  1528. Box [6].gadgetText := ADR (ILeer [25]);
  1529. Box [6].gadgetID := 6;
  1530.  
  1531. (* 10+ *)
  1532. Box [5] := Box [6];
  1533. Box [5].nextGadget := ADR (Box [6]);
  1534. Box [5].leftEdge := 540;
  1535. Box [5].gadgetText := ADR (ILeer [27]);
  1536. Box [5].gadgetID := 5;
  1537.  
  1538. (* - *)
  1539. Box [4] := Box [5];
  1540. Box [4].nextGadget := ADR (Box [5]);
  1541. Box [4].leftEdge := 490;
  1542. Box [4].gadgetText := ADR (ILeer [29]);
  1543. Box [4].gadgetID := 4;
  1544.  
  1545. (* + *)
  1546. Box [3] := Box [4];
  1547. Box [3].nextGadget := ADR (Box [4]);
  1548. Box [3].leftEdge := 440;
  1549. Box [3].gadgetText := ADR (ILeer [31]);
  1550. Box [3].gadgetID := 3;
  1551.  
  1552. (* Wert von Paar Nr. *)
  1553. Box [2] := Box [7];
  1554.  
  1555. WITH Box [2] DO
  1556.    nextGadget := ADR (Box [3]);
  1557.    leftEdge := 327;
  1558.    topEdge := 40;
  1559.    width := 60;
  1560.    activation := activation + ActivationFlagSet {longint};
  1561.    gadgetRender := ADR (Rahmen [4]);
  1562.    specialInfo := ADR (SInfo [2]);
  1563.    gadgetID := 2;
  1564. END (* WITH Box [2] *);
  1565.  
  1566. (* Wert von Anzahl *)
  1567. Box [1] := Box [2];
  1568. Box [1].nextGadget := ADR (Box [2]);
  1569. Box [1].topEdge := 20;
  1570. Box [1].leftEdge := 400;
  1571. Box [1].specialInfo := ADR (SInfo [1]);
  1572. Box [1].gadgetID := 1;
  1573.  
  1574. (* Screen öffnen *)
  1575. WITH NBildschirm DO
  1576.    leftEdge := 0;
  1577.    topEdge := 0;
  1578.    width := 640;
  1579.    height := 200;
  1580.    depth := 3;
  1581.    detailPen := 0;
  1582.    blockPen := 1;
  1583.    viewModes := ViewModeSet {hires};
  1584.    type := customScreen;
  1585.    font := ADR (Attr);
  1586.    defaultTitle := ADR (Screentitel);
  1587.    gadgets := NIL;
  1588.    customBitMap := NIL;
  1589. END (* WITH NBildschirm *);
  1590.  
  1591. Bildschirm := OpenScreen (NBildschirm);
  1592.  
  1593. Assert (Bildschirm # NIL, ADR ("konnte Screen nicht öffnen!"));
  1594.  
  1595. (* Farben *)
  1596. SetRGB4 (ADR (Bildschirm^.viewPort), Blaugrau ,  4,  4,  5);
  1597. SetRGB4 (ADR (Bildschirm^.viewPort), Hellblau ,  9, 13, 15);
  1598. SetRGB4 (ADR (Bildschirm^.viewPort), Schwarz  ,  0,  0,  0);
  1599. SetRGB4 (ADR (Bildschirm^.viewPort), Dunkelrot,  5,  0,  0);
  1600. SetRGB4 (ADR (Bildschirm^.viewPort), Weissrot , 15, 14, 14);
  1601. SetRGB4 (ADR (Bildschirm^.viewPort), Weiss    , 15, 15, 15);
  1602. SetRGB4 (ADR (Bildschirm^.viewPort), Rot      , 15,  0,  0);
  1603. SetRGB4 (ADR (Bildschirm^.viewPort), Gelb     , 15, 15,  0);
  1604.  
  1605. (* Fenster öffnen *)
  1606. WITH NFenster DO
  1607.    leftEdge := 0;
  1608.    topEdge := 12;
  1609.    width := 640;
  1610.    height := 188;
  1611.    detailPen := Blaugrau;
  1612.    blockPen := Hellblau;
  1613.    idcmpFlags := IDCMPFlagSet {gadgetUp};
  1614.    flags := WindowFlagSet {windowDepth, activate};
  1615.    firstGadget := ADR (Box [1]);
  1616.    checkMark := NIL;
  1617.    title := ADR (Fenstertitel);
  1618.    screen := Bildschirm;
  1619.    bitMap := NIL;
  1620.    minWidth := width;
  1621.    minHeight := height;
  1622.    maxWidth := width;
  1623.    maxHeight := height;
  1624.    type := customScreen;
  1625. END (* WITH NFenster *);
  1626.  
  1627. BFenster := OpenWindow (NFenster);
  1628.  
  1629. Assert (BFenster # NIL, ADR ("konnte Fenster nicht öffnen"));
  1630.  
  1631. DrawBorder (BFenster^.rPort, ADR (Rahmen [8]), 0, 0);
  1632.  
  1633. PrintIText (BFenster^.rPort, ADR (IText [1]), 0, 0);
  1634.  
  1635. GadgetAn (ADR (Box [ 1]), BFenster, NIL);
  1636. GadgetAn (ADR (Box [20]), BFenster, NIL);
  1637. Error := ActivateGadget (ADR (Box [1]), BFenster, NIL);
  1638.  
  1639. REPEAT
  1640.    WaitPort (BFenster^.userPort);
  1641.    Nachricht := GetMsg (BFenster^.userPort);
  1642.  
  1643.    IF Nachricht # NIL THEN
  1644.       Flags := Nachricht^.class;
  1645.       GewGad := Nachricht^.iAddress;
  1646.       ReplyMsg (Nachricht);
  1647.  
  1648.       (* na, welches ist es denn? *)
  1649.       (* Die folgende CASE-Anweisung war ursprünglich recht klein und *)
  1650.       (* ist erst im Laufe der Zeit immer größer geworden. Ich        *)
  1651.       (* schreibe sie jetzt nicht mehr um!                            *)
  1652.       CASE GewGad^.gadgetID OF
  1653.          | 1: (* Anzahl der Paare *)
  1654.               Error := FALSE;
  1655.  
  1656.               IF NOT ErstesMal THEN
  1657.                  ReqText [1].iText := ADR ("Sind Sie sicher, daß Sie");
  1658.                  ReqText [2].iText := ADR ("von vorn beginnen wollen?");
  1659.                  ReqText [3].iText := ADR (Ja);
  1660.                  ReqText [4].iText := ADR (Nein);
  1661.  
  1662.                  (* alles von vorn? *)
  1663.                  Error := MakeRequest (ADR (ReqText [3]),
  1664.                                        ADR (ReqText [4]),
  1665.                                        ADR (ReqText [1]),
  1666.                                        BFenster,
  1667.                                        2                 );
  1668.  
  1669.                  IF Error THEN
  1670.                     IF Gerade.Adresse # NIL THEN
  1671.                        Deallocate (Gerade.Adresse);
  1672.                     END (* IF Gerade.Adresse *);
  1673.  
  1674.                     Gerade.Adresse := NIL;
  1675.                     InitGerade (Gerade);
  1676.  
  1677.                     IF DFenster # NIL THEN
  1678.                        CloseWindow (DFenster);
  1679.                        DFenster := NIL;
  1680.                     END (* IF DFenster *);
  1681.  
  1682.                     IF GFenster # NIL THEN
  1683.                        CloseWindow (GFenster);
  1684.                        GFenster := NIL;
  1685.                     END (* IF GFenster *);
  1686.  
  1687.                     FOR i := 11 TO 16 DO
  1688.                        EXCL (Box [i].flags, selected);
  1689.                     END (* FOR i *);
  1690.  
  1691.                     RefreshGList (ADR (Box [11]), BFenster, NIL, 6);
  1692.  
  1693.                     FOR i := 2 TO 23 DO
  1694.                        IF (NOT (gadgDisabled IN Box [i].flags)) AND
  1695.                           (i # 20) THEN
  1696.                           GadgetAus (ADR (Box [i]), BFenster, NIL);
  1697.                        END (* IF NOT *);
  1698.                     END (* FOR i *);
  1699.  
  1700.                     (* X und Y leeren *)
  1701.                     UXZahl := "";
  1702.                     UYZahl := "";
  1703.                     XZahl := UXZahl;
  1704.                     YZahl := UYZahl;
  1705.  
  1706.                     SInfo [3].numChars := 0;
  1707.                     SInfo [4].numChars := 0;
  1708.  
  1709.                     RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  1710.  
  1711.                  ELSE (* IF Error *)
  1712.                     (* Inhalt des Gadgets wiederherstellen... *)
  1713.                     ValToStr (Gerade.N, FALSE, SMaxPaare, 10,
  1714.                               AZiffern (Gerade.N), " ", Error);
  1715.                     USMaxPaare := SMaxPaare;
  1716.  
  1717.                     WITH SInfo [1] DO
  1718.                        bufferPos := 0;
  1719.                        dispPos := 0;
  1720.                        numChars := AZiffern (Gerade.N);
  1721.                        longInt := Gerade.N;
  1722.                     END (* WITH SInfo [1] *);
  1723.                     RefreshGadList (ADR (Box [1]), BFenster, NIL, 1);
  1724.                  END (* IF Error *);
  1725.               END (* IF NOT ErstesMal *);
  1726.  
  1727.               IF ErstesMal OR Error THEN
  1728.                  IF SInfo [1].longInt < 3 THEN
  1729.                     (* leider keine Ausgleichsgerade berechenbar *)
  1730.                     ReqText [1].iText :=
  1731.                     ADR ("Man braucht mindestens 2 Punkte für eine Gerade");
  1732.                     ReqText [2].iText :=
  1733.                        ADR ("und mindestens 3 für eine Ausgleichsrechnung!");
  1734.                     ReqText [3].iText := ADR (Ok);
  1735.                     Error := MakeRequest (ADR (ReqText [3]),
  1736.                                           ADR (ReqText [4]),
  1737.                                           ADR (ReqText [1]),
  1738.                                           BFenster,
  1739.                                           1                 );
  1740.  
  1741.                  ELSE (* IF SInfo *);
  1742.                     WITH Gerade DO
  1743.                        N := CARDINAL (SInfo [1].longInt);
  1744.                        Ziffern := CARDINAL (AZiffern (SInfo [1].longInt));
  1745.                        Groesse := 2 * N * SIZE (Wert^);
  1746.  
  1747.                        (* Speicher anfordern *)
  1748.                        Assert (Largest (FALSE) >= Groesse,
  1749.                                ADR (Speichermangel));
  1750.  
  1751.                        Allocate (Adresse, Groesse);
  1752.                        Assert (Adresse # NIL, ADR (Speichermangel));
  1753.                        Wert := Adresse;
  1754.  
  1755.                        M := 1;
  1756.                        SPaarNr := "1";
  1757.                        USPaarNr := SPaarNr;
  1758.                        RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1759.                     END (* WITH Gerade *);
  1760.  
  1761.                     GadgetAn (ADR (Box [ 2]), BFenster, NIL);
  1762.                     GadgetAn (ADR (Box [ 7]), BFenster, NIL);
  1763.                     GadgetAn (ADR (Box [ 8]), BFenster, NIL);
  1764.  
  1765.                     SPaarNr := "1";
  1766.                     SInfo [2].longInt := 1;
  1767.                     RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1768.  
  1769.                     Error := ActivateGadget (ADR (Box [7]), BFenster, NIL);
  1770.                  END (* IF SInfo *);
  1771.  
  1772.                  ErstesMal := FALSE;
  1773.               END (* IF ErstesMal OR Error *);
  1774.  
  1775.          | 2: (* Paar Nr. *)
  1776.               (* Paar Nr. aktualisieren *)
  1777.               IF (SInfo [2].longInt < 1) OR
  1778.               (SInfo [2].longInt > LONGINT (Gerade.M)) THEN
  1779.                  ReqText [1].iText := ADR ("Ein Element mit dieser");
  1780.                  ReqText [2].iText := ADR ("Nummer gibt es nicht!");
  1781.                  ReqText [3].iText := ADR (Ok);
  1782.                  Error := MakeRequest (ADR (ReqText [3]),
  1783.                                        ADR (ReqText [4]),
  1784.                                        ADR (ReqText [1]),
  1785.                                        BFenster,
  1786.                                        1                 );
  1787.  
  1788.                  Error := FALSE;
  1789.                  StrToVal (USPaarNr, SInfo [2].longInt, Error, 10,
  1790.                            Error);
  1791.                  SPaarNr := USPaarNr;
  1792.  
  1793.                  WITH SInfo [2] DO
  1794.                     bufferPos := 0;
  1795.                     dispPos := 0;
  1796.                     numChars := AZiffern (longInt);
  1797.                  END (* WITH SInfo [2] *);
  1798.  
  1799.                  RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1800.  
  1801.               ELSE (* Nummer ok *)
  1802.                  USPaarNr := SPaarNr;
  1803.  
  1804.                  AktualisiereG (Box [3], Box [4], Box [5], Box [6],
  1805.                                 BFenster, SInfo [2].longInt, Gerade.M);
  1806.  
  1807.                  (* X: aktualisieren *)
  1808.                  Wert := Gerade.Adresse;
  1809.                  INC (Wert, (SInfo [2].longInt - 1) * 2 *
  1810.                              SIZE (Wert^));
  1811.                  RealToStr (Wert^, XZahl, 15, 13, Exponent (Wert^), Error);
  1812.                  UXZahl := XZahl;
  1813.                  SInfo [4].bufferPos := 0;
  1814.                  SInfo [4].dispPos := 0;
  1815.                  SInfo [4].numChars := 15;
  1816.  
  1817.                  (* Y: aktualisieren *)
  1818.                  INC (Wert, SIZE (Wert^));
  1819.                  RealToStr (Wert^, YZahl, 15, 13, Exponent (Wert^), Error);
  1820.                  UYZahl := YZahl;
  1821.                  SInfo [3].bufferPos := 0;
  1822.                  SInfo [3].dispPos := 0;
  1823.                  SInfo [3].numChars := 15;
  1824.  
  1825.                  RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  1826.               END (* IF SInfo [2].longInt *);
  1827.  
  1828.          | 3: (* + *)
  1829.               (* Paar Nr. aktualisieren *)
  1830.               INC (SInfo [2].longInt);
  1831.               ValToStr (SInfo [2].longInt, FALSE, SPaarNr, 10,
  1832.                         AZiffern (SInfo [2].longInt), "0", Error);
  1833.               USPaarNr := SPaarNr;
  1834.  
  1835.               WITH SInfo [2] DO
  1836.                  bufferPos := 0;
  1837.                  dispPos := 0;
  1838.                  numChars := AZiffern (longInt);
  1839.               END (* WITH SInfo [2] *);
  1840.  
  1841.               RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1842.  
  1843.               AktualisiereG (Box [3], Box [4], Box [5], Box [6],
  1844.                              BFenster, SInfo [2].longInt, Gerade.M);
  1845.  
  1846.               (* X: aktualisieren *)
  1847.               Wert := Gerade.Adresse;
  1848.               INC (Wert, (SInfo [2].longInt - 1) * 2 * SIZE (Wert^));
  1849.               RealToStr (Wert^, XZahl, 15, 13, Exponent (Wert^), Error);
  1850.               UXZahl := XZahl;
  1851.               SInfo [4].bufferPos := 0;
  1852.               SInfo [4].dispPos := 0;
  1853.               SInfo [4].numChars := 15;
  1854.  
  1855.               (* Y: aktualisieren *)
  1856.               INC (Wert, SIZE (Wert^));
  1857.               RealToStr (Wert^, YZahl, 15, 13, Exponent (Wert^), Error);
  1858.               UYZahl := YZahl;
  1859.               SInfo [3].bufferPos := 0;
  1860.               SInfo [3].dispPos := 0;
  1861.               SInfo [3].numChars := 15;
  1862.  
  1863.               RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  1864.  
  1865.          | 4: (* - *)
  1866.               (* Paar Nr. aktualisieren *)
  1867.               DEC (SInfo [2].longInt);
  1868.               ValToStr (SInfo [2].longInt, FALSE, SPaarNr, 10,
  1869.                         AZiffern (SInfo [2].longInt), "0", Error);
  1870.               USPaarNr := SPaarNr;
  1871.  
  1872.               WITH SInfo [2] DO
  1873.                  bufferPos := 0;
  1874.                  dispPos := 0;
  1875.                  numChars := AZiffern (longInt);
  1876.               END (* WITH SInfo [2] *);
  1877.  
  1878.               RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1879.  
  1880.               AktualisiereG (Box [3], Box [4], Box [5], Box [6],
  1881.                              BFenster, SInfo [2].longInt, Gerade.M);
  1882.  
  1883.               (* X: aktualisieren *)
  1884.               Wert := Gerade.Adresse;
  1885.               INC (Wert, ((SInfo [2].longInt - 1) * 2 * SIZE (Wert^)));
  1886.               RealToStr (Wert^, XZahl, 15, 13, Exponent (Wert^), Error);
  1887.               UXZahl := XZahl;
  1888.               SInfo [4].bufferPos := 0;
  1889.               SInfo [4].dispPos := 0;
  1890.               SInfo [4].numChars := 15;
  1891.  
  1892.               (* Y: aktualisieren *)
  1893.               INC (Wert, SIZE (Wert^));
  1894.               RealToStr (Wert^, YZahl, 15, 13, Exponent (Wert^), Error);
  1895.               UYZahl := YZahl;
  1896.               SInfo [3].bufferPos := 0;
  1897.               SInfo [3].dispPos := 0;
  1898.               SInfo [3].numChars := 15;
  1899.  
  1900.               RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  1901.  
  1902.          | 5: (* 10+ *)
  1903.               (* Paar Nr. aktualisieren *)
  1904.               INC (SInfo [2].longInt, 10);
  1905.               ValToStr (SInfo [2].longInt, FALSE, SPaarNr, 10,
  1906.                         AZiffern (SInfo [2].longInt), " ", Error);
  1907.               USPaarNr := SPaarNr;
  1908.  
  1909.               WITH SInfo [2] DO
  1910.                  bufferPos := 0;
  1911.                  dispPos := 0;
  1912.                  numChars := AZiffern (longInt);
  1913.               END (* WITH SInfo [2] *);
  1914.  
  1915.               RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1916.  
  1917.               AktualisiereG (Box [3], Box [4], Box [5], Box [6],
  1918.                              BFenster, SInfo [2].longInt, Gerade.M);
  1919.  
  1920.               (* X: aktualisieren *)
  1921.               Wert := Gerade.Adresse;
  1922.               INC (Wert, (SInfo [2].longInt - 1) * 2 * SIZE (Wert^));
  1923.               RealToStr (Wert^, XZahl, 15, 13, Exponent (Wert^), Error);
  1924.               UXZahl := XZahl;
  1925.               SInfo [4].bufferPos := 0;
  1926.               SInfo [4].dispPos := 0;
  1927.               SInfo [4].numChars := 15;
  1928.  
  1929.               (* Y: aktualisieren *)
  1930.               INC (Wert, SIZE (Wert^));
  1931.               RealToStr (Wert^, YZahl, 15, 13, Exponent (Wert^), Error);
  1932.               UYZahl := YZahl;
  1933.               SInfo [3].bufferPos := 0;
  1934.               SInfo [3].dispPos := 0;
  1935.               SInfo [3].numChars := 15;
  1936.  
  1937.               RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  1938.  
  1939.          | 6: (* 10- *)
  1940.               (* Paar Nr. aktualisieren *)
  1941.               DEC (SInfo [2].longInt, 10);
  1942.               ValToStr (SInfo [2].longInt, FALSE, SPaarNr, 10,
  1943.                         AZiffern (SInfo [2].longInt), "0", Error);
  1944.               USPaarNr := SPaarNr;
  1945.  
  1946.               WITH SInfo [2] DO
  1947.                  bufferPos := 0;
  1948.                  dispPos := 0;
  1949.                  numChars := AZiffern (longInt);
  1950.               END (* WITH SInfo [2] *);
  1951.  
  1952.               RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  1953.  
  1954.               AktualisiereG (Box [3], Box [4], Box [5], Box [6],
  1955.                              BFenster, SInfo [2].longInt, Gerade.M);
  1956.  
  1957.               (* X: aktualisieren *)
  1958.               Wert := Gerade.Adresse;
  1959.               INC (Wert, (SInfo [2].longInt - 1) * 2 * SIZE (Wert^));
  1960.               RealToStr (Wert^, XZahl, 15, 13, Exponent (Wert^), Error);
  1961.               UXZahl := XZahl;
  1962.               SInfo [4].bufferPos := 0;
  1963.               SInfo [4].dispPos := 0;
  1964.               SInfo [4].numChars := 15;
  1965.  
  1966.               (* Y: aktualisieren *)
  1967.               INC (Wert, SIZE (Wert^));
  1968.               RealToStr (Wert^, YZahl, 15, 13, Exponent (Wert^), Error);
  1969.               UYZahl := YZahl;
  1970.               SInfo [3].bufferPos := 0;
  1971.               SInfo [3].dispPos := 0;
  1972.               SInfo [3].numChars := 15;
  1973.  
  1974.               RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  1975.  
  1976.          | 7: (* X-Gadget *)
  1977.               Wert := Gerade.Adresse;
  1978.               INC (Wert, (SInfo [2].longInt - 1) * 2 * SIZE (Wert^));
  1979.  
  1980.               StrToReal (XZahl, Wert^, Error);
  1981.  
  1982.               IF Error THEN
  1983.                  (* etwas schiefgelaufen *)
  1984.                  ReqText [1].iText := ADR ("Die Zahl bei X: ist");
  1985.                  ReqText [2].iText := ADR ("nicht reell!");
  1986.                  ReqText [3].iText := ADR (Ok);
  1987.  
  1988.                  Error := MakeRequest (ADR (ReqText [3]),
  1989.                                        ADR (ReqText [4]),
  1990.                                        ADR (ReqText [1]),
  1991.                                        BFenster,
  1992.                                        1                 );
  1993.  
  1994.                  XZahl := UXZahl;
  1995.                  RefreshGadList (ADR (Box [7]), BFenster, NIL, 1);
  1996.               ELSE (* IF Error *)
  1997.                  (* Y-Gadget aktivieren *)
  1998.                  Error := ActivateGadget (ADR (Box [8]), BFenster, NIL);
  1999.               END (* IF Error *);
  2000.  
  2001.          | 8: (* Y-Gadget *)
  2002.               Wert := Gerade.Adresse;
  2003.               INC (Wert, (SInfo [2].longInt - 1) * 2 * SIZE (Wert^) +
  2004.                          SIZE (Wert^));
  2005.  
  2006.               StrToReal (YZahl, Wert^, Error);
  2007.  
  2008.               IF Error THEN
  2009.                  (* etwas schiefgelaufen *)
  2010.                  ReqText [1].iText := ADR ("Die Zahl bei Y: ist");
  2011.                  ReqText [2].iText := ADR ("nicht reell!");
  2012.                  ReqText [3].iText := ADR (Ok);
  2013.  
  2014.                  Error := MakeRequest (ADR (ReqText [3]),
  2015.                                        ADR (ReqText [4]),
  2016.                                        ADR (ReqText [1]),
  2017.                                        BFenster,
  2018.                                        1                 );
  2019.  
  2020.                  YZahl := UYZahl;
  2021.                  Error := ActivateGadget (ADR (Box [8]), BFenster, NIL);
  2022.               ELSE (* IF Error *)
  2023.                  IF CARDINAL (SInfo [2].longInt) < Gerade.N THEN
  2024.                     (* PaarNr um eins erhöhen *)
  2025.                     INC (SInfo [2].longInt);
  2026.                     ValToStr (SInfo [2].longInt, FALSE, SPaarNr, 10,
  2027.                               AZiffern (SInfo [2].longInt), "0", Error);
  2028.                     USPaarNr := SPaarNr;
  2029.  
  2030.                     WITH SInfo [2] DO
  2031.                        bufferPos := 0;
  2032.                        dispPos := 0;
  2033.                        numChars := AZiffern (longInt);
  2034.                     END (* WITH SInfo [2] *);
  2035.  
  2036.                     RefreshGadList (ADR (Box [2]), BFenster, NIL, 1);
  2037.  
  2038.                     IF CARDINAL (SInfo [2].longInt) > Gerade.M THEN
  2039.                        (* das folgende Pärchen ist neu *)
  2040.                        UXZahl := "";
  2041.                        UYZahl := "";
  2042.                        XZahl := UXZahl;
  2043.                        YZahl := UYZahl;
  2044.  
  2045.                        SInfo [3].numChars := 0;
  2046.                        SInfo [4].numChars := 0;
  2047.  
  2048.                        Gerade.M := CARDINAL (SInfo [2].longInt);
  2049.  
  2050.                        INC (Wert, SIZE (Wert^));
  2051.                        Wert^ := 0.0;
  2052.                        INC (Wert, SIZE (Wert^));
  2053.                        Wert^ := 0.0;
  2054.  
  2055.                     ELSE (* IF CARDINAL *)
  2056.                        (* das folgende Pärchen wurde schon getippt *)
  2057.                        INC (Wert, SIZE (Wert^));
  2058.                        RealToStr (Wert^, XZahl, 15, 13, Exponent (Wert^),
  2059.                                   Error);
  2060.                        INC (Wert, SIZE (Wert^));
  2061.                        RealToStr (Wert^, YZahl, 15, 13, Exponent (Wert^),
  2062.                                   Error);
  2063.  
  2064.                        UXZahl := XZahl;
  2065.                        UYZahl := YZahl;
  2066.  
  2067.                        SInfo [3].numChars := 15;
  2068.                        SInfo [4].numChars := 15;
  2069.                     END (* IF CARDINAL *);
  2070.  
  2071.                     AktualisiereG (Box [3], Box [4], Box [5], Box [6],
  2072.                                    BFenster, SInfo [2].longInt,
  2073.                                    Gerade.M);
  2074.  
  2075.                     SInfo [3].bufferPos := 0;
  2076.                     SInfo [3].dispPos := 0;
  2077.  
  2078.                     SInfo [4].bufferPos := 0;
  2079.                     SInfo [4].dispPos := 0;
  2080.  
  2081.                     RefreshGadList (ADR (Box [7]), BFenster, NIL, 2);
  2082.                     Error := ActivateGadget (ADR (Box [7]), BFenster, NIL);
  2083.                  ELSE (* IF Gerade.M *)
  2084.                     (* alle Werte eingegeben! *)
  2085.                     GadgetAn (ADR (Box [ 9]), BFenster, NIL);
  2086.                     GadgetAn (ADR (Box [11]), BFenster, NIL);
  2087.                     GadgetAn (ADR (Box [12]), BFenster, NIL);
  2088.                     GadgetAn (ADR (Box [17]), BFenster, NIL);
  2089.                     GadgetAn (ADR (Box [22]), BFenster, NIL);
  2090.                     GadgetAn (ADR (Box [23]), BFenster, NIL);
  2091.  
  2092.                     Box [11].flags := Box [11].flags +
  2093.                                       GadgetFlagSet {selected};
  2094.                     RefreshGadList (ADR (Box [11]), BFenster, NIL, 1);
  2095.  
  2096.                     Box [23].flags := Box [23].flags +
  2097.                                       GadgetFlagSet {selected};
  2098.                     RefreshGadList (ADR (Box [23]), BFenster, NIL, 1);
  2099.                  END (* IF Gerade.M *);
  2100.               END (* IF Error *);
  2101.  
  2102.          | 9: (* Ausgleichsgerade berechnen *)
  2103.               ReqText [1].iText := ADR ("Sind Sie sicher, daß Sie die");
  2104.               ReqText [2].iText := ADR ("Eingabe abgeschlossen haben?");
  2105.               ReqText [3].iText := ADR (Ja);
  2106.               ReqText [4].iText := ADR (Nein);
  2107.  
  2108.               IF MakeRequest (ADR (ReqText [3]),
  2109.                               ADR (ReqText [4]),
  2110.                               ADR (ReqText [1]),
  2111.                               BFenster,
  2112.                               2                 ) THEN
  2113.                  GadgetAus (ADR (Box [ 2]), BFenster, NIL);
  2114.                  GadgetAus (ADR (Box [ 3]), BFenster, NIL);
  2115.                  GadgetAus (ADR (Box [ 4]), BFenster, NIL);
  2116.                  GadgetAus (ADR (Box [ 5]), BFenster, NIL);
  2117.                  GadgetAus (ADR (Box [ 6]), BFenster, NIL);
  2118.                  GadgetAus (ADR (Box [ 7]), BFenster, NIL);
  2119.                  GadgetAus (ADR (Box [ 8]), BFenster, NIL);
  2120.                  GadgetAus (ADR (Box [ 9]), BFenster, NIL);
  2121.                  GadgetAus (ADR (Box [21]), BFenster, NIL);
  2122.                  GadgetAus (ADR (Box [22]), BFenster, NIL);
  2123.                  GadgetAus (ADR (Box [23]), BFenster, NIL);
  2124.  
  2125.                  WITH Gerade.Daten DO
  2126.                     (* Mittelwert aller X und Y *)
  2127.                     XM := 0.0;
  2128.                     YM := 0.0;
  2129.                     Wert := Gerade.Adresse;
  2130.  
  2131.                     FOR i := 1 TO Gerade.N DO
  2132.                        XM := XM + Wert^;
  2133.  
  2134.                        INC (Wert, SIZE (Wert^));
  2135.  
  2136.                        YM := YM + Wert^;
  2137.  
  2138.                        IF i # Gerade.N THEN
  2139.                           INC (Wert, SIZE (Wert^));
  2140.  
  2141.                        ELSE (* IF i *)
  2142.                           Wert := Gerade.Adresse;
  2143.                        END (* IF i *);
  2144.                     END (* FOR i *);
  2145.  
  2146.                     XM := XM / LONGREAL (Gerade.N);
  2147.                     YM := YM / LONGREAL (Gerade.N);
  2148.  
  2149.                     (* Summe (Xi - XM)² *)
  2150.                     XIQQ := 0.0;
  2151.  
  2152.                     FOR i := 1 TO Gerade.N DO
  2153.                        Hilfe := Wert^ - XM;
  2154.                        XIQQ := XIQQ + (Hilfe * Hilfe);
  2155.  
  2156.                        IF i # Gerade.N THEN
  2157.                           INC (Wert, 2 * SIZE (Wert^));
  2158.  
  2159.                        ELSE
  2160.                           Wert := Gerade.Adresse;
  2161.                        END (* IF i *);
  2162.                     END (* FOR i *);
  2163.  
  2164.                     (* Standardabweichung aller X und Y *)
  2165.                     XS := sqrt (XIQQ / LONGREAL (Gerade.N - 1));
  2166.                     YS := 0.0;
  2167.  
  2168.                     INC (Wert, SIZE (Wert^));
  2169.  
  2170.                     FOR i := 1 TO Gerade.N DO
  2171.                        Hilfe := Wert^ - YM;
  2172.                        YS := YS + (Hilfe * Hilfe);
  2173.  
  2174.                        IF i # Gerade.N THEN
  2175.                           INC (Wert, 2 * SIZE (Wert^));
  2176.  
  2177.                        ELSE (* IF i *)
  2178.                           Wert := Gerade.Adresse;
  2179.                        END (* IF i *);
  2180.                     END (* For i *);
  2181.  
  2182.                     YS := sqrt (YS / LONGREAL (Gerade.N - 1));
  2183.  
  2184.                     (* Parameter der Ausgleichsgeraden y = Ax + B *)
  2185.                     IF Gerade.BBekannt THEN
  2186.                        A := 0.0;
  2187.  
  2188.                        Hilfe2 := 0.0;
  2189.  
  2190.                        FOR i := 1 TO Gerade.N DO
  2191.                           Hilfe := Wert^;
  2192.                           Hilfe2 := Hilfe2 + Wert^;
  2193.                           Hilfe3 := Hilfe3 + (Wert^ * Wert^);
  2194.                           INC (Wert, SIZE (Wert^));
  2195.  
  2196.                           A := A + (Hilfe * Wert^);
  2197.  
  2198.                           IF i # Gerade.N THEN
  2199.                              INC (Wert, SIZE (Wert^));
  2200.  
  2201.                           ELSE (* IF i *)
  2202.                              Wert := Gerade.Adresse;
  2203.                           END (* IF i *);
  2204.                        END (* FOR i *);
  2205.  
  2206.                        A := (A - (B * Hilfe2)) / Hilfe3;
  2207.  
  2208.                     ELSE (* IF Gerade.BBekannt *)
  2209.                        A := 0.0;
  2210.                        B := 0.0;
  2211.  
  2212.                        FOR i := 1 TO Gerade.N DO
  2213.                           Hilfe := Wert^;
  2214.                           INC (Wert, SIZE (Wert^));
  2215.  
  2216.                           A := A + ((XM - Hilfe) * (YM - Wert^));
  2217.  
  2218.                           IF i # Gerade.N THEN
  2219.                              INC (Wert, SIZE (Wert^));
  2220.  
  2221.                           ELSE (* IF i *)
  2222.                              Wert := Gerade.Adresse;
  2223.                           END (* IF i *);
  2224.                        END (* FOR i *);
  2225.  
  2226.                        A := A / XIQQ;
  2227.  
  2228.                        B := YM - (A * XM);
  2229.                     END (* IF Gerade.BBekannt *);
  2230.  
  2231.                     (* St. der Parameter und der A.-Geraden *)
  2232.                     GS := 0.0;
  2233.                     AS := 0.0;
  2234.                     BS := 0.0;
  2235.  
  2236.                     FOR i := 1 TO Gerade.N DO
  2237.                        Hilfe := (A * Wert^) + B;
  2238.  
  2239.                        INC (Wert, SIZE (Wert^));
  2240.  
  2241.                        GS := GS + ((Wert^ - Hilfe) * (Wert^ - Hilfe));
  2242.  
  2243.                        IF i # Gerade.N THEN
  2244.                           INC (Wert, SIZE (Wert^));
  2245.  
  2246.                        ELSE
  2247.                           Wert := Gerade.Adresse;
  2248.                        END (* IF i *);
  2249.                     END (* FOR i *);
  2250.  
  2251.                     GS := sqrt (GS / LONGREAL (Gerade.N - 2));
  2252.  
  2253.                     AS := sqrt (GS * GS / XIQQ);
  2254.  
  2255.                     IF Gerade.BBekannt THEN
  2256.                        BS := 0.0; (* ad definitionam *)
  2257.  
  2258.                     ELSE (* IF Gerade.BBekannt *)
  2259.                        BS := sqrt (((XM * XM / XIQQ) +
  2260.                                (1.0 / LONGREAL (Gerade.N))) * GS * GS);
  2261.                     END (* IF Gerade.BBekannt *);
  2262.  
  2263.                     (* Korrelationskoeffizient R *)
  2264.                     R := 0.0;
  2265.  
  2266.                     FOR i := 1 TO Gerade.N DO
  2267.                        Hilfe := Wert^ - XM;
  2268.  
  2269.                        INC (Wert, SIZE (Wert^));
  2270.  
  2271.                        R := R + (Hilfe * (Wert^ - YM));
  2272.  
  2273.                        IF i # Gerade.N THEN
  2274.                           INC (Wert, SIZE (Wert^));
  2275.  
  2276.                        ELSE
  2277.                           Wert := Gerade.Adresse;
  2278.                        END (* IF i *);
  2279.                     END (* FOR i *);
  2280.  
  2281.                     R := R / (LONGREAL (Gerade.N - 1) * XS * YS);
  2282.                  END (* WITH Gerade.Daten *);
  2283.  
  2284.                  (* Gadgets aktivieren *)
  2285.                  GadgetAn (ADR (Box [13]), BFenster, NIL);
  2286.                  GadgetAn (ADR (Box [14]), BFenster, NIL);
  2287.  
  2288.                  Box [13].flags := Box [13].flags + GadgetFlagSet {selected};
  2289.                  Box [14].flags := Box [14].flags + GadgetFlagSet {selected};
  2290.                  RefreshGadList (ADR (Box [13]), BFenster, NIL, 2);
  2291.               END (* IF MakeRequest *);
  2292.  
  2293.               (* Daten der Gerade in ein Fenster schreiben *)
  2294.  
  2295.               WITH NFenster DO
  2296.                  leftEdge := 0;
  2297.                  topEdge := 8;
  2298.                  width := 640;
  2299.                  height := 192;
  2300.                  detailPen := Blaugrau;
  2301.                  blockPen := Hellblau;
  2302.                  idcmpFlags := IDCMPFlagSet {};
  2303.                  flags := WindowFlagSet {windowDepth, activate};
  2304.                  firstGadget := NIL;
  2305.                  checkMark := NIL;
  2306.                  title := ADR (Fenstertitel2);
  2307.                  screen := Bildschirm;
  2308.                  bitMap := NIL;
  2309.                  minWidth := width;
  2310.                  minHeight := height;
  2311.                  maxWidth := width;
  2312.                  maxHeight := height;
  2313.                  type := customScreen;
  2314.               END (* WITH NFenster *);
  2315.  
  2316.               DFenster := OpenWindow (NFenster);
  2317.  
  2318.               (* schreibe: Anzahl der Wertepaare, Parameter A und B, *)
  2319.               (* Standardabweichung von A, B und der Geraden sowie   *)
  2320.               (* den linearen Korrelationskoeffizienten              *)
  2321.  
  2322.               WITH Gerade DO
  2323.                  TextZeile := " Ausgleichsgerade Y = AX + B:";
  2324.                  PrintText (DFenster, TextZeile, 10, 21);
  2325.  
  2326.                  TextZeile := " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
  2327.                  PrintText (DFenster, TextZeile, 10, 31);
  2328.  
  2329.                  TextZeile := " Anzahl der Wertepaare           : ";
  2330.                  ValToStr (N, FALSE, HilfsText, 10, Laenge (N), " ",
  2331.                     Error);
  2332.                  Concat (TextZeile, HilfsText);
  2333.                  PrintText (DFenster, TextZeile, 10, 42);
  2334.  
  2335.                  TextZeile := " Mittelwert der X                : ";
  2336.                  RealToStr (Daten.XM, HilfsText, 15, 13,
  2337.                     Exponent (Daten.XM), Error);
  2338.                  Concat (TextZeile, HilfsText);
  2339.                  PrintText (DFenster, TextZeile, 10, 53);
  2340.  
  2341.                  TextZeile := " Mittelwert der Y                : ";
  2342.                  RealToStr (Daten.YM, HilfsText, 15, 13,
  2343.                     Exponent (Daten.YM), Error);
  2344.                  Concat (TextZeile, HilfsText);
  2345.                  PrintText (DFenster, TextZeile, 10, 64);
  2346.  
  2347.                  TextZeile := " Standardabweichung der X        : ";
  2348.                  RealToStr (Daten.XS, HilfsText, 15, 13,
  2349.                     Exponent (Daten.XS), Error);
  2350.                  Concat (TextZeile, HilfsText);
  2351.                  PrintText (DFenster, TextZeile, 10, 75);
  2352.  
  2353.                  TextZeile := " Standardabweichung der Y        : ";
  2354.                  RealToStr (Daten.YS, HilfsText, 15, 13,
  2355.                     Exponent (Daten.YS), Error);
  2356.                  Concat (TextZeile, HilfsText);
  2357.                  PrintText (DFenster, TextZeile, 10, 86);
  2358.  
  2359.                  TextZeile := " Parameter A                     : ";
  2360.                  RealToStr (Daten.A, HilfsText, 15, 13,
  2361.                     Exponent (Daten.A), Error);
  2362.                  Concat (TextZeile, HilfsText);
  2363.                  PrintText (DFenster, TextZeile, 10, 97);
  2364.  
  2365.                  IF BBekannt THEN
  2366.                     TextZeile := " (vorher bekannter) Parameter B  : ";
  2367.  
  2368.                  ELSE (* IF BBekannt *)
  2369.                     TextZeile := " Parameter B                     : ";
  2370.                  END (* IF BBekannt *);
  2371.  
  2372.                  RealToStr (Daten.B, HilfsText, 15, 13,
  2373.                     Exponent (Daten.B), Error);
  2374.                  Concat (TextZeile, HilfsText);
  2375.                  PrintText (DFenster, TextZeile, 10, 108);
  2376.  
  2377.                  TextZeile := " Standardabweichung von A        : ";
  2378.                  RealToStr (Daten.AS, HilfsText, 15, 13,
  2379.                     Exponent (Daten.AS), Error);
  2380.                  Concat (TextZeile, HilfsText);
  2381.                  PrintText (DFenster, TextZeile, 10, 119);
  2382.  
  2383.                  TextZeile := " Standardabweichung von B        : ";
  2384.                  RealToStr (Daten.BS, HilfsText, 15, 13,
  2385.                     Exponent (Daten.BS), Error);
  2386.                  Concat (TextZeile, HilfsText);
  2387.                  PrintText (DFenster, TextZeile, 10, 130);
  2388.  
  2389.                  TextZeile := " Standardabweichung der Geraden  : ";
  2390.                  RealToStr (Daten.GS, HilfsText, 15, 13,
  2391.                     Exponent (Daten.GS), Error);
  2392.                  Concat (TextZeile, HilfsText);
  2393.                  PrintText (DFenster, TextZeile, 10, 142);
  2394.  
  2395.                  TextZeile := " linearer Korrelationskoeffizient: ";
  2396.                  RealToStr (Daten.R, HilfsText,15, 13,
  2397.                     Exponent (Daten.R), Error);
  2398.                  Concat (TextZeile, HilfsText);
  2399.                  PrintText (DFenster, TextZeile, 10, 153);
  2400.               END (* WITH Gerade *);
  2401.  
  2402.               GadgetAn (ADR (Box [10]), BFenster, NIL);
  2403.  
  2404.          |10: (* Gerade zeichnen *);
  2405.  
  2406.               IF GFenster # NIL THEN
  2407.                  CloseWindow (GFenster);
  2408.                  GFenster := NIL;
  2409.               END (* IF GFenster *);
  2410.  
  2411.               (* Grafik-Fenster öffnen *)
  2412.               WITH NFenster DO
  2413.                  leftEdge := 0;
  2414.                  topEdge := 4;
  2415.                  width := 640;
  2416.                  height := 196;
  2417.                  detailPen := Blaugrau;
  2418.                  blockPen := Hellblau;
  2419.                  idcmpFlags := IDCMPFlagSet {gadgetUp}; (* für die Requester *)
  2420.                  flags := WindowFlagSet {windowDepth, activate};
  2421.                  firstGadget := NIL;
  2422.                  checkMark := NIL;
  2423.                  title := ADR (Fenstertitel3);
  2424.                  screen := Bildschirm;
  2425.                  bitMap := NIL;
  2426.                  minWidth := width;
  2427.                  minHeight := height;
  2428.                  maxWidth := width;
  2429.                  maxHeight := height;
  2430.                  type := customScreen;
  2431.               END (* WITH NFenster *);
  2432.  
  2433.               GFenster := OpenWindow (NFenster);
  2434.  
  2435.               IF GFenster = NIL THEN
  2436.                  ReqText [1].iText := ADR ("Ich konnte das");
  2437.                  ReqText [2].iText := ADR ("Grafikfenster nicht öffnen!");
  2438.                  ReqText [3].iText := ADR (Ok);
  2439.                  Error := MakeRequest (ADR (ReqText [3]),
  2440.                                        ADR (ReqText [4]),
  2441.                                        ADR (ReqText [1]),
  2442.                                        BFenster,
  2443.                                        1                 );
  2444.  
  2445.               ELSE (* GFenster offen *)
  2446.                  (* größten und kleinsten X- und Y-Wert finden *)
  2447.                  Wert := Gerade.Adresse;
  2448.                  XMin := Wert^;
  2449.                  XMax := Wert^;
  2450.  
  2451.                  INC (Wert, SIZE (Wert^));
  2452.                  YMin := Wert^;
  2453.                  YMax := Wert^;
  2454.  
  2455.                  FOR i := 2 TO Gerade.N DO
  2456.                     INC (Wert, SIZE (Wert^));
  2457.  
  2458.                     IF Wert^ < XMin THEN
  2459.                        XMin := Wert^;
  2460.  
  2461.                     ELSE
  2462.                        IF Wert^ > XMax THEN
  2463.                           XMax := Wert^;
  2464.                        END (* IF Wert^ *);
  2465.                     END (* IF Wert^ *);
  2466.  
  2467.                     INC (Wert, SIZE (Wert^));
  2468.  
  2469.                     IF Wert^ < YMin THEN
  2470.                        YMin := Wert^;
  2471.  
  2472.                     ELSE
  2473.                        IF Wert^ > YMax THEN
  2474.                           YMax := Wert^;
  2475.                        END (* IF Wert^ *);
  2476.                     END (* IF Wert^ *);
  2477.                  END (* FOR i *);
  2478.  
  2479.                  Wert := Gerade.Adresse;
  2480.  
  2481.                  (* Schnittpunkt der Geraden mit der Y-Achse *)
  2482.  
  2483.                  IF NOT ((XMin <= 0.0) AND (XMax >= 0.0) AND
  2484.                     (Gerade.Daten.B >= YMin) AND
  2485.                     (Gerade.Daten.B <= YMax)) THEN
  2486.                     (* der Punkt Y(X=0) ist noch nicht im Bild *)
  2487.                     ReqText [1].iText := ADR ("Soll der Punkt Y(X=0)");
  2488.                     ReqText [2].iText := ADR ("eingezeichnet werden?");
  2489.                     ReqText [3].iText := ADR (Ja);
  2490.                     ReqText [4].iText := ADR (Nein);
  2491.  
  2492.                     IF MakeRequest (ADR (ReqText [3]),
  2493.                                     ADR (ReqText [4]),
  2494.                                     ADR (ReqText [1]),
  2495.                                     GFenster,
  2496.                                     2                 ) THEN
  2497.  
  2498.                        (* ja, er soll *)
  2499.  
  2500.                        IF XMin > 0.0 THEN
  2501.                           XMin := 0.0;
  2502.                        END (* IF XMin *);
  2503.  
  2504.                        IF XMax < 0.0 THEN
  2505.                           XMax := 0.0;
  2506.                        END (* IF XMax *);
  2507.  
  2508.                        IF YMin > Gerade.Daten.B THEN
  2509.                           YMin := Gerade.Daten.B;
  2510.                        END (* IF YMin *);
  2511.  
  2512.                        IF YMax < Gerade.Daten.B THEN
  2513.                           YMax := Gerade.Daten.B;
  2514.                        END (* IF YMax *);
  2515.                     END (* IF MakeRequest *);
  2516.                  END (* IF NOT *);
  2517.  
  2518.                  (* Schnittpunkt der Geraden mit der X-Achse *)
  2519.  
  2520.                  MBDurchA := - Gerade.Daten.B / Gerade.Daten.A; (* = X(Y=0) *)
  2521.  
  2522.                  IF NOT ((YMin <= 0.0) AND (YMax >= 0.0) AND
  2523.                     (XMin <= MBDurchA) AND (XMax >= MBDurchA)) THEN
  2524.                     (* der Punkt X(Y=0) ist noch nicht im Bild *)
  2525.                     ReqText [1].iText := ADR ("Soll der Punkt X(Y=0)");
  2526.                     ReqText [2].iText := ADR ("eingezeichnet werden?");
  2527.                     ReqText [3].iText := ADR (Ja);
  2528.                     ReqText [4].iText := ADR (Nein);
  2529.  
  2530.                     IF MakeRequest (ADR (ReqText [3]),
  2531.                                     ADR (ReqText [4]),
  2532.                                     ADR (ReqText [1]),
  2533.                                     GFenster,
  2534.                                     2                 ) THEN
  2535.  
  2536.                        (* ja, er soll *)
  2537.  
  2538.                        IF XMin > MBDurchA THEN
  2539.                           XMin := MBDurchA;
  2540.                        END (* IF XMin *);
  2541.  
  2542.                        IF XMax < MBDurchA THEN
  2543.                           XMax := MBDurchA;
  2544.                        END (* IF XMax *);
  2545.  
  2546.                        IF YMin > 0.0 THEN
  2547.                           YMin := 0.0;
  2548.                        END (* IF YMin *);
  2549.  
  2550.                        IF YMax < 0.0 THEN
  2551.                           YMax := 0.0;
  2552.                        END (* IF YMax *);
  2553.                     END (* IF MakeRequest *);
  2554.                  END (* IF NOT *);
  2555.  
  2556.                  Breite := XMax - XMin;
  2557.                  Hoehe := YMax - YMin;
  2558.  
  2559.                  (* kleiner Rand *)
  2560.  
  2561.                  XMax := XMax + (0.05 * Breite);
  2562.                  XMin := XMin - (0.05 * Breite);
  2563.  
  2564.                  YMax := YMax + (0.05 * Hoehe);
  2565.                  YMin := YMin - (0.05 * Hoehe);
  2566.  
  2567.                  Breite := XMax - XMin;
  2568.                  Hoehe := YMax - YMin;
  2569.  
  2570.                  (* ein Pixel ist... *)
  2571.  
  2572.                  XPixelBr := Breite / LONGREAL (SpalteMax);
  2573.                  YPixelBr := Hoehe / LONGREAL (ZeileMax);
  2574.  
  2575.                  (* Zum Zeichnen weißer Hintergrund *)
  2576.                  SetAPen (GFenster^.rPort, Weiss);
  2577.  
  2578.                  RectFill (GFenster^.rPort, Spalte (XMin) - 2, Zeile (YMax) - 1,
  2579.                     Spalte (XMax) + 2, Zeile (YMin) + 1);
  2580.  
  2581.                  (* Achsenkreuz zeichnen: *)
  2582.  
  2583.                  SetAPen (GFenster^.rPort, Schwarz);
  2584.  
  2585.                  (* X-Achse: *)
  2586.                  IF ImRastPort (Zeile (0.0), y) THEN
  2587.                     Move (GFenster^.rPort, Spalte (XMin), Zeile (0.0));
  2588.                     Draw (GFenster^.rPort, Spalte (XMax), Zeile (0.0));
  2589.  
  2590.                     (* Pfeil an X-Achse *)
  2591.                     Move (GFenster^.rPort, Spalte (XMax) - 4, Zeile (0.0) - 2);
  2592.                     Draw (GFenster^.rPort, Spalte (XMax), Zeile (0.0));
  2593.                     Draw (GFenster^.rPort, Spalte (XMax) - 4, Zeile (0.0) + 2);
  2594.  
  2595.                     (* Buchstabe X *)
  2596.                     Schrift := "x\o";
  2597.  
  2598.                     WITH ISchrift DO
  2599.                        frontPen := Schwarz;
  2600.                        backPen := Weiss;
  2601.                        drawMode := jam2;
  2602.                        leftEdge := SpalteMax - 9;
  2603.                        iTextFont := NIL;
  2604.                        iText := ADR (Schrift);
  2605.                        nextText := NIL;
  2606.                     END (* WITH ISchrift *);
  2607.  
  2608.                     IF Zeile (0.0) > (ZeileMin + 14) THEN
  2609.                        (* obendrüber *)
  2610.                        ISchrift.topEdge := Zeile (0.0) - 11;
  2611.  
  2612.                     ELSE (* IF Zeile *)
  2613.                        (* untendrunter *)
  2614.                        ISchrift.topEdge := Zeile (0.0) + 3;
  2615.                     END (* IF Zeile *);
  2616.  
  2617.                     PrintIText (GFenster^.rPort, ADR (ISchrift), 0, 0);
  2618.                  END (* IF ImRastPort *);
  2619.  
  2620.                  (* Y-Achse: *)
  2621.                  IF ImRastPort (Spalte (0.0), x) THEN
  2622.                     Move (GFenster^.rPort, Spalte (0.0), Zeile (YMax));
  2623.                     Draw (GFenster^.rPort, Spalte (0.0), Zeile (YMin));
  2624.  
  2625.                     Move (GFenster^.rPort, Spalte (0.0) + 1, Zeile (YMax));
  2626.                     Draw (GFenster^.rPort, Spalte (0.0) + 1, Zeile (YMin));
  2627.  
  2628.                     (* Pfeil an Y-Achse *)
  2629.                     Move (GFenster^.rPort, Spalte (0.0) - 4, Zeile (YMax) + 2);
  2630.                     Draw (GFenster^.rPort, Spalte (0.0), Zeile (YMax));
  2631.                     Draw (GFenster^.rPort, Spalte (0.0) + 1, Zeile (YMax));
  2632.                     Draw (GFenster^.rPort, Spalte (0.0) + 5, Zeile (YMax) + 2);
  2633.  
  2634.                     (* Buchstabe Y *)
  2635.                     Schrift := "y\o";
  2636.  
  2637.                     WITH ISchrift DO
  2638.                        frontPen := Schwarz;
  2639.                        backPen := Weiss;
  2640.                        drawMode := jam2;
  2641.                        topEdge := ZeileMin;
  2642.                        iTextFont := NIL;
  2643.                        iText := ADR (Schrift);
  2644.                        nextText := NIL;
  2645.                     END (* WITH ISchrift *);
  2646.  
  2647.                     IF Spalte (0.0) < (SpalteMax - 17) THEN
  2648.                        (* rechts *)
  2649.                        ISchrift.leftEdge := Spalte (0.0) + 8;
  2650.  
  2651.                     ELSE (* IF Zeile *)
  2652.                        (* links *)
  2653.                        ISchrift.leftEdge := Spalte (0.0) - 16;
  2654.                     END (* IF Zeile *);
  2655.  
  2656.                     PrintIText (GFenster^.rPort, ADR (ISchrift), 0, 0);
  2657.                  END (* IF ImRastPort *);
  2658.  
  2659.                  (* die Punkte: *)
  2660.  
  2661.                  FOR i := 1 TO Gerade.N DO
  2662.                     X := Spalte (Wert^);
  2663.  
  2664.                     IF (i = 1) OR (i = Gerade.N) THEN
  2665.                        (* auf X-Achse *)
  2666.                        IF ImRastPort (Zeile (0.0), y) THEN
  2667.                           DrawCross (GFenster^.rPort, X, Zeile (0.0));
  2668.  
  2669.                           RealToStr (Wert^, Schrift, 8, 6, Exponent (Wert^), Error);
  2670.  
  2671.                           WITH ISchrift DO
  2672.                              frontPen := Schwarz;
  2673.                              backPen := Weiss;
  2674.                              drawMode := jam2;
  2675.  
  2676.                              IF Zeile (0.0) <= ZeileMax THEN
  2677.                                 topEdge := Zeile (0.0) + 4;
  2678.  
  2679.                              ELSE
  2680.                                 topEdge := Zeile (0.0) - 11;
  2681.                              END (* IF Zeile *);
  2682.  
  2683.                              IF (X + 36) > SpalteMax THEN
  2684.                                 leftEdge := SpalteMax - 90;
  2685.  
  2686.                              ELSE (* IF (X *)
  2687.                                 IF (X - 36) < SpalteMin THEN
  2688.                                    leftEdge := SpalteMin;
  2689.  
  2690.                                 ELSE (* IF (X - 36) *)
  2691.                                    leftEdge := X - 36;
  2692.                                 END (* IF (X - 36 *);
  2693.                              END (* IF (X *);
  2694.  
  2695.                              iTextFont := NIL;
  2696.                              iText := ADR (Schrift);
  2697.                              nextText := NIL;
  2698.                           END (* WITH ISchrift *);
  2699.  
  2700.                           PrintIText (GFenster^.rPort, ADR (ISchrift), 0, 0);
  2701.                        END (* IF ImRastPort *);
  2702.                     END (* IF (i *);
  2703.  
  2704.                     INC (Wert, SIZE (Wert^));
  2705.  
  2706.                     Y := Zeile (Wert^);
  2707.  
  2708.                     IF (i = 1) OR (i = Gerade.N) THEN
  2709.                        (* Y-Achse *)
  2710.                        IF ImRastPort (Spalte (0.0), x) THEN
  2711.                           DrawCross (GFenster^.rPort, Spalte (0.0), Y);
  2712.  
  2713.                           RealToStr (Wert^, Schrift, 8, 6, Exponent (Wert^), Error);
  2714.  
  2715.                           WITH ISchrift DO
  2716.                              frontPen := Schwarz;
  2717.                              backPen := Weiss;
  2718.                              drawMode := jam2;
  2719.  
  2720.                              IF (Y - 4) < (ZeileMin + 10) THEN
  2721.                                 topEdge := ZeileMin + 10;
  2722.  
  2723.                              ELSE (* IF (Y - 4 *)
  2724.                                 topEdge := Y - 4;
  2725.                              END (* IF (Y - 4 *);
  2726.  
  2727.                              IF Spalte (0.0) < (SpalteMax - 80) THEN
  2728.                                 leftEdge := Spalte (0.0) + 4;
  2729.  
  2730.                              ELSE (* IF Spalte *)
  2731.                                 leftEdge := Spalte (0.0) - 80;
  2732.                              END (* IF Spalte *);
  2733.  
  2734.                              iTextFont := NIL;
  2735.                              iText := ADR (Schrift);
  2736.                              nextText := NIL;
  2737.                           END (* WITH ISchrift *);
  2738.  
  2739.                           PrintIText (GFenster^.rPort, ADR (ISchrift), 0, 0);
  2740.                        END (* IF ImRastPort *);
  2741.                     END (* IF (i *);
  2742.  
  2743.                     INC (Wert, SIZE (Wert^));
  2744.  
  2745.                     DrawCross (GFenster^.rPort, X, Y);
  2746.                  END (* FOR i *);
  2747.  
  2748.                  Wert := Gerade.Adresse;
  2749.  
  2750.                  (* Die Gerade *)
  2751.  
  2752.                  SetAPen (GFenster^.rPort, Rot);
  2753.  
  2754.                  IF ImRastPort (Zeile ((Gerade.Daten.A * XMin) + Gerade.Daten.B), y)
  2755.                     THEN
  2756.                     Move (GFenster^.rPort, Spalte (XMin),
  2757.                        Zeile ((Gerade.Daten.A * XMin) + Gerade.Daten.B));
  2758.  
  2759.                  ELSE (* IF ImRastPort *)
  2760.                     IF Gerade.Daten.A >= 0.0 THEN
  2761.                        Move (GFenster^.rPort, Spalte ((YMin - Gerade.Daten.B) /
  2762.                           Gerade.Daten.A), Zeile (YMin));
  2763.  
  2764.                     ELSE (* IF Gerade.Daten.A *)
  2765.                        Move (GFenster^.rPort, Spalte ((YMax - Gerade.Daten.B) /
  2766.                           Gerade.Daten.A), Zeile (YMax));
  2767.                     END (* IF Gerade.Daten.A *);
  2768.                  END (* IF ImRastPort *);
  2769.  
  2770.                  IF ImRastPort (Zeile ((Gerade.Daten.A * XMax) + Gerade.Daten.B), y)
  2771.                     THEN
  2772.                     Draw (GFenster^.rPort, Spalte (XMax),
  2773.                        Zeile ((Gerade.Daten.A * XMax) + Gerade.Daten.B));
  2774.  
  2775.                  ELSE (* IF ImRastPort *)
  2776.                     IF Gerade.Daten.A >= 0.0 THEN
  2777.                        Draw (GFenster^.rPort, Spalte ((YMax - Gerade.Daten.B) /
  2778.                           Gerade.Daten.A), Zeile (YMax));
  2779.  
  2780.                     ELSE (* IF Gerade.Daten.A *)
  2781.                        Draw (GFenster^.rPort, Spalte ((YMin - Gerade.Daten.B) /
  2782.                           Gerade.Daten.A), Zeile (YMin));
  2783.                     END (* IF Gerade.Daten.A *);
  2784.                  END (* IF ImRastPort *);
  2785.  
  2786.                  GadgetAn (ADR (Box [15]), BFenster, NIL);
  2787.                  GadgetAn (ADR (Box [16]), BFenster, NIL);
  2788.  
  2789.                  Box [15].flags := Box [15].flags + GadgetFlagSet {selected};
  2790.                  Box [16].flags := Box [16].flags + GadgetFlagSet {selected};
  2791.                  RefreshGadList (ADR (Box [15]), BFenster, NIL, 2);
  2792.               END (* IF GFenster = NIL *);
  2793.  
  2794.          |11: (* Wertepaare - nichts tun *);
  2795.  
  2796.          |12: (* Seitenvorschub - nichts tun *);
  2797.  
  2798.          |13: (* Daten der Gerade - nichts tun *);
  2799.  
  2800.          |14: (* Seitenvorschub - nichts tun *);
  2801.  
  2802.          |15: (* Ausgleichsgerade - nichts tun *);
  2803.  
  2804.          |16: (* Seitenvorschub - nichts tun *);
  2805.  
  2806.          |17: (* drucken *)
  2807.               Datei := Open (ADR (PRT), newFile);
  2808.  
  2809.               IF Datei # NIL THEN
  2810.                  Ausgabe :=
  2811.                  " A U S G L E I C H S G E R A D E  Y = A X + B";
  2812.                   Schreibe (Datei, Ausgabe, 1);
  2813.                   Wert := Gerade.Adresse;
  2814.  
  2815.                  IF selected IN Box [11].flags THEN
  2816.                     RUmGadget (Box [11], An, BFenster);
  2817.  
  2818.                     FOR i := 1 TO Gerade.N DO
  2819.                        Ausgabe := " X(";
  2820.                        ValToStr (i, FALSE, SHilfe, 10, Ziffern, " ",
  2821.                                  Error);
  2822.                        Concat (Ausgabe, SHilfe);
  2823.                        Concat (Ausgabe, ") = ");
  2824.                        RealToStr (Wert^, SHilfe, 12, 8,
  2825.                                   Exponent (Wert^), Error);
  2826.                        Concat (Ausgabe, SHilfe);
  2827.                        Concat (Ausgabe, ",  Y(");
  2828.                        ValToStr (i, FALSE, SHilfe, 10, Ziffern, " ",
  2829.                                  Error);
  2830.                        Concat (Ausgabe, SHilfe);
  2831.                        Concat (Ausgabe, ") = ");
  2832.                        INC (Wert, SIZE (Wert^));
  2833.                        RealToStr (Wert^, SHilfe, 12, 8,
  2834.                                   Exponent (Wert^), Error);
  2835.                        Concat (Ausgabe, SHilfe);
  2836.                        Concat (Ausgabe, ";");
  2837.  
  2838.                        Schreibe (Datei, Ausgabe, 0);
  2839.  
  2840.                        IF i # Gerade.N THEN
  2841.                           INC (Wert, SIZE (Wert^));
  2842.  
  2843.                        ELSE
  2844.                           Wert := Gerade.Adresse;
  2845.                        END (* IF i *);
  2846.                     END (* FOR i *);
  2847.  
  2848.                     RUmGadget (Box [11], Aus, BFenster);
  2849.                  END (* IF selected *);
  2850.  
  2851.                  Ausgabe := "";
  2852.  
  2853.                  IF selected IN Box [12].flags THEN
  2854.                     (* Seitenvorschub *)
  2855.                     RUmGadget (Box [12], An, BFenster);
  2856.  
  2857.                     Schreibe (Datei, " \f", 0);
  2858.  
  2859.                     RUmGadget (Box [12], Aus, BFenster);
  2860.  
  2861.                  ELSE (* IF selected *)
  2862.                     Schreibe (Datei, Ausgabe, 0);
  2863.                  END (* IF selected *);
  2864.  
  2865.                  IF selected IN Box [13].flags THEN
  2866.                     RUmGadget (Box [13], An, BFenster);
  2867.  
  2868.                     Ausgabe := " Anzahl der Wertepaare: ";
  2869.                     ValToStr (Gerade.N, FALSE, SHilfe, 10, Ziffern,
  2870.                               " ", Error);
  2871.                     Concat (Ausgabe, SHilfe);
  2872.                     Schreibe (Datei, Ausgabe, 1);
  2873.  
  2874.                     Ausgabe := " Mittelwert der X-Werte: ";
  2875.                     RealToStr (Gerade.Daten.XM, SHilfe, 12, 8,
  2876.                                Exponent (Gerade.Daten.XM), Error);
  2877.                     Concat (Ausgabe, SHilfe);
  2878.                     Schreibe (Datei, Ausgabe, 1);
  2879.  
  2880.                     Ausgabe := " Mittelwert der Y-Werte: ";
  2881.                     RealToStr (Gerade.Daten.YM, SHilfe, 12, 8,
  2882.                                Exponent (Gerade.Daten.YM), Error);
  2883.                     Concat (Ausgabe, SHilfe);
  2884.                     Schreibe (Datei, Ausgabe, 1);
  2885.  
  2886.                     Ausgabe := " Standardabweichung der X-Werte: ";
  2887.                     RealToStr (Gerade.Daten.XS, SHilfe, 12, 8,
  2888.                                Exponent (Gerade.Daten.XS), Error);
  2889.                     Concat (Ausgabe, SHilfe);
  2890.                     Schreibe (Datei, Ausgabe, 1);
  2891.  
  2892.                     Ausgabe := " Standardabweichung der Y-Werte: ";
  2893.                     RealToStr (Gerade.Daten.YS, SHilfe, 12, 8,
  2894.                                Exponent (Gerade.Daten.YS), Error);
  2895.                     Concat (Ausgabe, SHilfe);
  2896.                     Schreibe (Datei, Ausgabe, 1);
  2897.  
  2898.                     Ausgabe :=
  2899.                        " Parameter A der Ausgleichsgeraden: ";
  2900.                     RealToStr (Gerade.Daten.A, SHilfe, 12, 8,
  2901.                                Exponent (Gerade.Daten.A), Error);
  2902.                     Concat (Ausgabe, SHilfe);
  2903.                     Schreibe (Datei, Ausgabe, 1);
  2904.  
  2905.                     Ausgabe := " Einheit des Parameters A: ";
  2906.                     Schreibe (Datei, Ausgabe, 1);
  2907.  
  2908.                     IF Gerade.BBekannt THEN
  2909.                        Ausgabe :=
  2910.                        " vorher bekannter Parameter B der Ausgleichsgeraden: ";
  2911.  
  2912.                     ELSE (* IF BBekannt *)
  2913.                        Ausgabe :=
  2914.                           " Parameter B der Ausgleichsgeraden: ";
  2915.                     END (* IF BBekannt *);
  2916.  
  2917.                     RealToStr (Gerade.Daten.B, SHilfe, 12, 8,
  2918.                                Exponent (Gerade.Daten.B), Error);
  2919.                     Concat (Ausgabe, SHilfe);
  2920.                     Schreibe (Datei, Ausgabe, 1);
  2921.  
  2922.                     Ausgabe := " Einheit des Parameters B: ";
  2923.                     Schreibe (Datei, Ausgabe, 1);
  2924.  
  2925.                     Ausgabe :=
  2926.                     " (N-1) - Standardabweichung des Parameters A: ";
  2927.                     RealToStr (Gerade.Daten.AS, SHilfe, 12, 8,
  2928.                                Exponent (Gerade.Daten.AS), Error);
  2929.                     Concat (Ausgabe, SHilfe);
  2930.                     Schreibe (Datei, Ausgabe, 1);
  2931.  
  2932.                     Ausgabe :=
  2933.                     " (N-1) - Standardabweichung des Parameters B: ";
  2934.                     RealToStr (Gerade.Daten.BS, SHilfe, 12, 8,
  2935.                                Exponent (Gerade.Daten.BS), Error);
  2936.                     Concat (Ausgabe, SHilfe);
  2937.                     Schreibe (Datei, Ausgabe, 1);
  2938.  
  2939.                     Ausgabe :=
  2940.                       " Standardabweichung der Ausgleichsgeraden: ";
  2941.                     RealToStr (Gerade.Daten.GS, SHilfe, 12, 8,
  2942.                                Exponent (Gerade.Daten.GS), Error);
  2943.                     Concat (Ausgabe, SHilfe);
  2944.                     Schreibe (Datei, Ausgabe, 1);
  2945.  
  2946.                     Ausgabe :=
  2947.                        " linearer Korrelationskoeffizient R: ";
  2948.                     RealToStr (Gerade.Daten.R, SHilfe, 12, 8,
  2949.                                Exponent (Gerade.Daten.R), Error);
  2950.                     Concat (Ausgabe, SHilfe);
  2951.                     Schreibe (Datei, Ausgabe, 1);
  2952.  
  2953.                     RUmGadget (Box [13], Aus, BFenster);
  2954.                  END (* IF selected *);
  2955.  
  2956.                  Ausgabe := "";
  2957.  
  2958.                  IF selected IN Box [14].flags THEN
  2959.                     (* Seitenvorschub *)
  2960.                     RUmGadget (Box [14], An, BFenster);
  2961.  
  2962.                     Schreibe (Datei, " \f", 0);
  2963.  
  2964.                     RUmGadget (Box [14], Aus, BFenster);
  2965.                  ELSE (* IF selected *)
  2966.                     Schreibe (Datei, Ausgabe, 0);
  2967.                  END (* IF selected *);
  2968.  
  2969.                  Close (Datei);
  2970.                  Datei := NIL;
  2971.  
  2972.                  (* die Gerade als Grafik *)
  2973.  
  2974.                  IF GFenster # NIL THEN
  2975.                     IF selected IN Box [15].flags THEN
  2976.                        Port := CreatePort (ADR ("Ausgleichsgerade drucken\o"), 0);
  2977.                        BildReq := CreateExtIO (Port, SIZE (BildReq^));
  2978.  
  2979.                        IF BildReq # NIL THEN
  2980.                           OpenDevice (ADR (printerName), 0, BildReq, LONGSET {});
  2981.  
  2982.                           WITH BildReq^ DO
  2983.                              command := dumpRPort;
  2984.                              rastPort := GFenster^.rPort;
  2985.                              colorMap := Bildschirm^.viewPort.colorMap;
  2986.                              modes := Bildschirm^.viewPort.modes;
  2987.                              srcX := 5;
  2988.                              srcY := 13;
  2989.                              srcWidth := 630;
  2990.                              srcHeight := 180;
  2991.                              destCols := 0;
  2992.                              destRows := 0;
  2993.                              special := SpecialSet {fullCols, aspect, noFormFeed};
  2994.                           END (* With BildReq^ *);
  2995.  
  2996.                           RUmGadget (Box [15], An, BFenster);
  2997.                           DoIO (BildReq); (* drucken... *)
  2998.                           RUmGadget (Box [15], Aus, BFenster);
  2999.  
  3000.                           CloseDevice (BildReq);
  3001.                           DeleteExtIO (BildReq);
  3002.                           BildReq := NIL;
  3003.                        END (* IF BildReq *);
  3004.  
  3005.                        DeletePort (Port);
  3006.                        Port := NIL;
  3007.                     END (* IF selected *);
  3008.                  END (* IF GFenster *);
  3009.  
  3010.                  IF selected IN Box [16].flags THEN
  3011.                     Datei := Open (ADR (PRT), newFile);
  3012.  
  3013.                     IF Datei # NIL THEN
  3014.                        (* Seitenvorschub *)
  3015.                        RUmGadget (Box [16], An, BFenster);
  3016.  
  3017.                        Schreibe (Datei, " \f", 0);
  3018.  
  3019.                        RUmGadget (Box [16], Aus, BFenster);
  3020.  
  3021.                        Close (Datei);
  3022.                        Datei := NIL;
  3023.                     END (* IF Datei *);
  3024.                  END (* IF selected *);
  3025.  
  3026.               ELSE (* IF Datei *)
  3027.                  ReqText [1].iText :=
  3028.                     ADR ("Ich kann nicht drucken,");
  3029.                  ReqText [2].iText :=
  3030.                     ADR ("Ihr Drucker ist nicht erreichbar!");
  3031.                  ReqText [3].iText := ADR (Ok);
  3032.                  Error := MakeRequest (ADR (ReqText [3]),
  3033.                                        ADR (ReqText [4]),
  3034.                                        ADR (ReqText [1]),
  3035.                                        BFenster,
  3036.                                        1                 );
  3037.               END (* IF Datei *);
  3038.  
  3039.          |18: (* Laden, noch nicht implementiert *);
  3040.  
  3041.          |19: (* Speichern, noch nicht implementiert *);
  3042.  
  3043.          |20: (* Ende *)
  3044.               ReqText [1].iText := ADR ("Wollen Sie das Programm");
  3045.               ReqText [2].iText := ADR ("wirklich beenden?");
  3046.               ReqText [3].iText := ADR (Ja);
  3047.               ReqText [4].iText := ADR (Nein);
  3048.  
  3049.               Programmende := MakeRequest (ADR (ReqText [3]),
  3050.                                            ADR (ReqText [4]),
  3051.                                            ADR (ReqText [1]),
  3052.                                            BFenster,
  3053.                                            2                 );
  3054.  
  3055.          |21: (* Y(X=0) eingegeben *)
  3056.               StrToReal (YVonX, Gerade.Daten.B, Error);
  3057.  
  3058.               IF Error THEN
  3059.                  (* etwas schiefgelaufen *)
  3060.                  ReqText [1].iText :=
  3061.                     ADR ("Die Zahl bei Y(X=0) ist");
  3062.                  ReqText [2].iText := ADR ("nicht reell!");
  3063.                  ReqText [3].iText := ADR (Ok);
  3064.  
  3065.                  Error := MakeRequest (ADR (ReqText [3]),
  3066.                                        ADR (ReqText [4]),
  3067.                                        ADR (ReqText [1]),
  3068.                                        BFenster,
  3069.                                        1                 );
  3070.  
  3071.                  YVonX := UYVonX;
  3072.                  RefreshGadList (ADR (Box [21]), BFenster, NIL, 1);
  3073.               ELSE (* IF Error *)
  3074.                  UYVonX := YVonX;
  3075.               END (* IF Error *);
  3076.  
  3077.          |22: (* B bekannt! *)
  3078.               IF NOT Gerade.BBekannt THEN
  3079.                  (* "n. bek." löschen *)
  3080.                  Box [22].flags := Box [22].flags +
  3081.                                    GadgetFlagSet {selected};
  3082.                  Box [23].flags := Box [23].flags -
  3083.                                    GadgetFlagSet {selected};
  3084.  
  3085.                  RefreshGadList (ADR (Box [22]), BFenster, NIL, 2);
  3086.  
  3087.                  (* Y(X=0) aktivieren *)
  3088.                  GadgetAn (ADR (Box [21]), BFenster, NIL);
  3089.                  Error := ActivateGadget (ADR (Box [21]), BFenster, NIL);
  3090.  
  3091.                  Gerade.BBekannt := TRUE;
  3092.               ELSE (* das Gadget soll angewählt bleiben! *)
  3093.                  Box [22].flags := Box [22].flags +
  3094.                                    GadgetFlagSet {selected};
  3095.                  RefreshGadList (ADR (Box [22]), BFenster, NIL, 1);
  3096.               END (* IF NOT *);
  3097.  
  3098.          |23: (* B nicht bekannt *)
  3099.               IF Gerade.BBekannt THEN
  3100.                  (* "bekannt" löschen *)
  3101.                  Box [22].flags := Box [22].flags -
  3102.                                    GadgetFlagSet {selected};
  3103.                  Box [23].flags := Box [23].flags +
  3104.                                    GadgetFlagSet {selected};
  3105.  
  3106.                  RefreshGadList (ADR (Box [22]), BFenster, NIL, 2);
  3107.  
  3108.                  (* Y(X=0) deaktivieren *)
  3109.                  GadgetAus (ADR (Box [21]), BFenster, NIL);
  3110.  
  3111.                  Gerade.BBekannt := FALSE;
  3112.               ELSE (* das Gadget soll angewählt bleiben! *)
  3113.                  Box [23].flags := Box [23].flags +
  3114.                                    GadgetFlagSet {selected};
  3115.                  RefreshGadList (ADR (Box [23]), BFenster, NIL, 1);
  3116.               END (* IF NOT *);
  3117.       END (* CASE GewGad^.gadgetID *);
  3118.    END (* IF Nachricht *);
  3119. UNTIL Programmende;
  3120.  
  3121. (* --------------------------------------------------------------------- *)
  3122.  
  3123. CLOSE; (* aufräumen... *)
  3124.  
  3125. IF BFenster # NIL THEN
  3126.    CloseWindow (BFenster);
  3127.    BFenster := NIL;
  3128. END (* IF BFenster *);
  3129.  
  3130. IF DFenster # NIL THEN
  3131.    CloseWindow (DFenster);
  3132.    DFenster := NIL;
  3133. END (* IF DFenster *);
  3134.  
  3135. IF GFenster # NIL THEN
  3136.    CloseWindow (GFenster);
  3137.    GFenster := NIL;
  3138. END (* IF GFenster *);
  3139.  
  3140. IF Bildschirm # NIL THEN
  3141.    CloseScreen (Bildschirm);
  3142.    Bildschirm := NIL;
  3143. END (* IF Bildschirm *);
  3144.  
  3145. IF Font # NIL THEN
  3146.    CloseFont (Font);
  3147.    Font := NIL;
  3148. END (* IF Font *);
  3149.  
  3150. IF Gerade.Adresse # NIL THEN
  3151.    Deallocate (Gerade.Adresse);
  3152.    Gerade.Adresse := NIL;
  3153. END (* IF Gerade.Adresse *);
  3154.  
  3155. IF Datei # NIL THEN
  3156.    Close (Datei);
  3157.    Datei := NIL;
  3158. END (* IF Datei *);
  3159.  
  3160. IF BildReq # NIL THEN
  3161.    CloseDevice (BildReq);
  3162.    DeleteExtIO (BildReq);
  3163.    BildReq := NIL;
  3164. END (* IF BildReq *);
  3165.  
  3166. END AusgleichsgeradeV2 (* Modul *).
  3167.